public commit

app/src/data/relations/RelationField.ts

@@ -0,0 +1,101 @@
+import { type Static, StringEnum, Type } from "core/utils";
+import type { EntityManager } from "../entities";
+import { Field, type SchemaResponse, baseFieldConfigSchema } from "../fields";
+import type { EntityRelation } from "./EntityRelation";
+import type { EntityRelationAnchor } from "./EntityRelationAnchor";
+
+const CASCADES = ["cascade", "set null", "set default", "restrict", "no action"] as const;
+
+export const relationFieldConfigSchema = Type.Composite([
+   baseFieldConfigSchema,
+   Type.Object({
+      reference: Type.String(),
+      target: Type.String(), // @todo: potentially has to be an instance!
+      target_field: Type.Optional(Type.String({ default: "id" })),
+      on_delete: Type.Optional(StringEnum(CASCADES, { default: "set null" }))
+   })
+]);
+/*export const relationFieldConfigSchema = baseFieldConfigSchema.extend({
+   reference: z.string(),
+   target: z.string(),
+   target_field: z.string().catch("id"),
+});*/
+
+export type RelationFieldConfig = Static<typeof relationFieldConfigSchema>;
+export type RelationFieldBaseConfig = { label?: string };
+
+export class RelationField extends Field<RelationFieldConfig> {
+   override readonly type = "relation";
+
+   protected getSchema() {
+      return relationFieldConfigSchema;
+   }
+
+   /*constructor(name: string, config?: Partial<RelationFieldConfig>) {
+      //relation_name = relation_name || target.name;
+      //const name = [relation_name, target.getPrimaryField().name].join("_");
+      super(name, config);
+
+      //console.log(this.config);
+      //this.relation.target = target;
+      //this.relation.name = relation_name;
+   }*/
+
+   static create(
+      relation: EntityRelation,
+      target: EntityRelationAnchor,
+      config?: RelationFieldBaseConfig
+   ) {
+      const name = [
+         target.reference ?? target.entity.name,
+         target.entity.getPrimaryField().name
+      ].join("_");
+      //console.log('name', name);
+      return new RelationField(name, {
+         ...config,
+         required: relation.required,
+         reference: target.reference,
+         target: target.entity.name,
+         target_field: target.entity.getPrimaryField().name
+      });
+   }
+
+   reference() {
+      return this.config.reference;
+   }
+
+   target() {
+      return this.config.target;
+   }
+
+   targetField(): string {
+      return this.config.target_field!;
+   }
+
+   override schema(): SchemaResponse {
+      return this.useSchemaHelper("integer", (col) => {
+         //col.references('person.id').onDelete('cascade').notNull()
+         // @todo: implement cascading?
+
+         return col
+            .references(`${this.config.target}.${this.config.target_field}`)
+            .onDelete(this.config.on_delete ?? "set null");
+      });
+   }
+
+   override transformRetrieve(value: any): any {
+      return value;
+   }
+
+   override async transformPersist(value: any, em: EntityManager<any>): Promise<any> {
+      throw new Error("This function should not be called");
+   }
+
+   override toJsonSchema() {
+      return this.toSchemaWrapIfRequired(
+         Type.Number({
+            $ref: `${this.config?.target}#/properties/${this.config?.target_field}`
+         })
+      );
+   }
+}