@zenstackhq/runtime 3.0.0-alpha.21 → 3.0.0-alpha.22

package/dist/index.js

@@ -6255,6 +6255,7 @@ __name(processCasing, "processCasing");
 // src/client/helpers/schema-db-pusher.ts
 import { invariant as invariant10 } from "@zenstackhq/common-helpers";
 import { sql as sql8 } from "kysely";
+import toposort from "toposort";
 import { match as match18 } from "ts-pattern";
 var SchemaDbPusher = class {
   static {
@@ -6274,41 +6275,79 @@ var SchemaDbPusher = class {
           await createEnum.execute();
         }
       }
-      for (const model of Object.keys(this.schema.models)) {
-        const createTable = this.createModelTable(tx, model);
+      const sortedModels = this.sortModels(this.schema.models);
+      for (const modelDef of sortedModels) {
+        const createTable = this.createModelTable(tx, modelDef);
         await createTable.execute();
       }
     });
   }
-  createModelTable(kysely, model) {
-    let table = kysely.schema.createTable(model).ifNotExists();
-    const modelDef = requireModel(this.schema, model);
+  sortModels(models) {
+    const graph = [];
+    for (const model of Object.values(models)) {
+      let added = false;
+      if (model.baseModel) {
+        const baseDef = requireModel(this.schema, model.baseModel);
+        graph.push([
+          model,
+          baseDef
+        ]);
+        added = true;
+      }
+      for (const field of Object.values(model.fields)) {
+        if (field.relation && field.relation.fields && field.relation.references) {
+          const targetModel = requireModel(this.schema, field.type);
+          graph.push([
+            model,
+            targetModel
+          ]);
+          added = true;
+        }
+      }
+      if (!added) {
+        graph.push([
+          model,
+          void 0
+        ]);
+      }
+    }
+    return toposort(graph).reverse().filter((m) => !!m);
+  }
+  createModelTable(kysely, modelDef) {
+    let table = kysely.schema.createTable(modelDef.name).ifNotExists();
     for (const [fieldName, fieldDef] of Object.entries(modelDef.fields)) {
+      if (fieldDef.originModel && !fieldDef.id) {
+        continue;
+      }
       if (fieldDef.relation) {
-        table = this.addForeignKeyConstraint(table, model, fieldName, fieldDef);
+        table = this.addForeignKeyConstraint(table, modelDef.name, fieldName, fieldDef);
       } else if (!this.isComputedField(fieldDef)) {
-        table = this.createModelField(table, fieldName, fieldDef, modelDef);
+        table = this.createModelField(table, fieldDef, modelDef);
       }
     }
-    table = this.addPrimaryKeyConstraint(table, model, modelDef);
-    table = this.addUniqueConstraint(table, model, modelDef);
+    if (modelDef.baseModel) {
+      const baseModelDef = requireModel(this.schema, modelDef.baseModel);
+      table = table.addForeignKeyConstraint(`fk_${modelDef.baseModel}_delegate`, baseModelDef.idFields, modelDef.baseModel, baseModelDef.idFields, (cb) => cb.onDelete("cascade").onUpdate("cascade"));
+    }
+    table = this.addPrimaryKeyConstraint(table, modelDef);
+    table = this.addUniqueConstraint(table, modelDef);
     return table;
   }
   isComputedField(fieldDef) {
     return fieldDef.attributes?.some((a) => a.name === "@computed");
   }
-  addPrimaryKeyConstraint(table, model, modelDef) {
+  addPrimaryKeyConstraint(table, modelDef) {
     if (modelDef.idFields.length === 1) {
       if (Object.values(modelDef.fields).some((f) => f.id)) {
         return table;
       }
     }
     if (modelDef.idFields.length > 0) {
-      table = table.addPrimaryKeyConstraint(`pk_${model}`, modelDef.idFields);
+      table = table.addPrimaryKeyConstraint(`pk_${modelDef.name}`, modelDef.idFields);
     }
     return table;
   }
-  addUniqueConstraint(table, model, modelDef) {
+  addUniqueConstraint(table, modelDef) {
     for (const [key, value] of Object.entries(modelDef.uniqueFields)) {
       invariant10(typeof value === "object", "expecting an object");
       if ("type" in value) {
@@ -6316,17 +6355,17 @@ var SchemaDbPusher = class {
         if (fieldDef.unique) {
           continue;
         }
-        table = table.addUniqueConstraint(`unique_${model}_${key}`, [
+        table = table.addUniqueConstraint(`unique_${modelDef.name}_${key}`, [
           key
         ]);
       } else {
-        table = table.addUniqueConstraint(`unique_${model}_${key}`, Object.keys(value));
+        table = table.addUniqueConstraint(`unique_${modelDef.name}_${key}`, Object.keys(value));
       }
     }
     return table;
   }
-  createModelField(table, fieldName, fieldDef, modelDef) {
-    return table.addColumn(fieldName, this.mapFieldType(fieldDef), (col) => {
+  createModelField(table, fieldDef, modelDef) {
+    return table.addColumn(fieldDef.name, this.mapFieldType(fieldDef), (col) => {
       if (fieldDef.id && modelDef.idFields.length === 1) {
         col = col.primaryKey();
       }