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

package/dist/{contract-XFKcwhq7.d.cts → contract-D8U59Syb.d.cts}

@@ -562,6 +562,7 @@ declare abstract class BaseCrudDialect<Schema extends SchemaDef> {
     protected and(eb: ExpressionBuilder<any, any>, ...args: Expression<SqlBool>[]): Expression<SqlBool>;
     protected or(eb: ExpressionBuilder<any, any>, ...args: Expression<SqlBool>[]): Expression<SqlBool>;
     protected not(eb: ExpressionBuilder<any, any>, ...args: Expression<SqlBool>[]): ExpressionWrapper<any, any, SqlBool>;
+    fieldRef(model: string, field: string, eb: ExpressionBuilder<any, any>, modelAlias?: string): ExpressionWrapper<any, any, unknown>;
     abstract get provider(): DataSourceProviderType;
     /**
      * Builds selection for a relation field.

package/dist/{contract-XFKcwhq7.d.ts → contract-D8U59Syb.d.ts}

@@ -562,6 +562,7 @@ declare abstract class BaseCrudDialect<Schema extends SchemaDef> {
     protected and(eb: ExpressionBuilder<any, any>, ...args: Expression<SqlBool>[]): Expression<SqlBool>;
     protected or(eb: ExpressionBuilder<any, any>, ...args: Expression<SqlBool>[]): Expression<SqlBool>;
     protected not(eb: ExpressionBuilder<any, any>, ...args: Expression<SqlBool>[]): ExpressionWrapper<any, any, SqlBool>;
+    fieldRef(model: string, field: string, eb: ExpressionBuilder<any, any>, modelAlias?: string): ExpressionWrapper<any, any, unknown>;
     abstract get provider(): DataSourceProviderType;
     /**
      * Builds selection for a relation field.

package/dist/index.cjs

@@ -582,7 +582,7 @@ var BaseCrudDialect = class {
       if (fieldDef.relation) {
         result = this.and(eb, result, this.buildRelationFilter(eb, model, modelAlias, key, fieldDef, payload));
       } else {
-        const fieldRef = buildFieldRef(this.schema, fieldDef.originModel ?? model, key, this.options, eb, fieldDef.originModel ?? modelAlias);
+        const fieldRef = this.fieldRef(fieldDef.originModel ?? model, key, eb, fieldDef.originModel ?? modelAlias);
         if (fieldDef.array) {
           result = this.and(eb, result, this.buildArrayFilter(eb, fieldRef, fieldDef, payload));
         } else {
@@ -905,7 +905,7 @@ var BaseCrudDialect = class {
           (0, import_common_helpers.invariant)(value && typeof value === "object", `invalid orderBy value for field "${field}"`);
           for (const [k, v] of Object.entries(value)) {
             (0, import_common_helpers.invariant)(v === "asc" || v === "desc", `invalid orderBy value for field "${field}"`);
-            result = result.orderBy((eb) => aggregate(eb, import_kysely.sql.ref(`${modelAlias}.${k}`), field), import_kysely.sql.raw(this.negateSort(v, negated)));
+            result = result.orderBy((eb) => aggregate(eb, this.fieldRef(model, k, eb, modelAlias), field), import_kysely.sql.raw(this.negateSort(v, negated)));
           }
           continue;
         }
@@ -914,7 +914,7 @@ var BaseCrudDialect = class {
             (0, import_common_helpers.invariant)(value && typeof value === "object", 'invalid orderBy value for field "_count"');
             for (const [k, v] of Object.entries(value)) {
               (0, import_common_helpers.invariant)(v === "asc" || v === "desc", `invalid orderBy value for field "${field}"`);
-              result = result.orderBy((eb) => eb.fn.count(import_kysely.sql.ref(k)), import_kysely.sql.raw(this.negateSort(v, negated)));
+              result = result.orderBy((eb) => eb.fn.count(this.fieldRef(model, k, eb, modelAlias)), import_kysely.sql.raw(this.negateSort(v, negated)));
             }
             continue;
           }
@@ -923,10 +923,11 @@ var BaseCrudDialect = class {
         }
         const fieldDef = requireField(this.schema, model, field);
         if (!fieldDef.relation) {
+          const fieldRef = this.fieldRef(model, field, (0, import_kysely.expressionBuilder)(), modelAlias);
           if (value === "asc" || value === "desc") {
-            result = result.orderBy(import_kysely.sql.ref(`${modelAlias}.${field}`), this.negateSort(value, negated));
+            result = result.orderBy(fieldRef, this.negateSort(value, negated));
           } else if (value && typeof value === "object" && "nulls" in value && "sort" in value && (value.sort === "asc" || value.sort === "desc") && (value.nulls === "first" || value.nulls === "last")) {
-            result = result.orderBy(import_kysely.sql.ref(`${modelAlias}.${field}`), import_kysely.sql.raw(`${this.negateSort(value.sort, negated)} nulls ${value.nulls}`));
+            result = result.orderBy(fieldRef, import_kysely.sql.raw(`${this.negateSort(value.sort, negated)} nulls ${value.nulls}`));
           }
         } else {
           const relationModel = fieldDef.type;
@@ -988,7 +989,7 @@ var BaseCrudDialect = class {
   buildSelectField(query, model, modelAlias, field) {
     const fieldDef = requireField(this.schema, model, field);
     if (fieldDef.computed) {
-      return query.select((eb) => buildFieldRef(this.schema, model, field, this.options, eb).as(field));
+      return query.select((eb) => this.fieldRef(model, field, eb, modelAlias).as(field));
     } else if (!fieldDef.originModel) {
       return query.select(import_kysely.sql.ref(`${modelAlias}.${field}`).as(field));
     } else {
@@ -1079,6 +1080,9 @@ var BaseCrudDialect = class {
   not(eb, ...args) {
     return eb.not(this.and(eb, ...args));
   }
+  fieldRef(model, field, eb, modelAlias) {
+    return buildFieldRef(this.schema, model, field, this.options, eb, modelAlias);
+  }
 };
 
 // src/client/crud/dialects/postgresql.ts
@@ -1172,7 +1176,7 @@ var PostgresCrudDialect = class extends BaseCrudDialect {
     if (payload === true || !payload.select) {
       objArgs.push(...Object.entries(relationModelDef.fields).filter(([, value]) => !value.relation).filter(([name]) => !(typeof payload === "object" && payload.omit?.[name] === true)).map(([field]) => [
         import_kysely2.sql.lit(field),
-        buildFieldRef(this.schema, relationModel, field, this.options, eb)
+        this.fieldRef(relationModel, field, eb)
       ]).flatMap((v) => v));
     } else if (payload.select) {
       objArgs.push(...Object.entries(payload.select).filter(([, value]) => value).map(([field, value]) => {
@@ -1184,7 +1188,7 @@ var PostgresCrudDialect = class extends BaseCrudDialect {
           ];
         } else {
           const fieldDef = requireField(this.schema, relationModel, field);
-          const fieldValue = fieldDef.relation ? eb.ref(`${parentAlias}$${relationField}$${field}.$j`) : buildFieldRef(this.schema, relationModel, field, this.options, eb);
+          const fieldValue = fieldDef.relation ? eb.ref(`${parentAlias}$${relationField}$${field}.$j`) : this.fieldRef(relationModel, field, eb);
           return [
             import_kysely2.sql.lit(field),
             fieldValue
@@ -1335,7 +1339,7 @@ var SqliteCrudDialect = class extends BaseCrudDialect {
       if (payload === true || !payload.select) {
         objArgs.push(...Object.entries(relationModelDef.fields).filter(([, value]) => !value.relation).filter(([name]) => !(typeof payload === "object" && payload.omit?.[name] === true)).map(([field]) => [
           import_kysely3.sql.lit(field),
-          buildFieldRef(this.schema, relationModel, field, this.options, eb)
+          this.fieldRef(relationModel, field, eb)
         ]).flatMap((v) => v));
       } else if (payload.select) {
         objArgs.push(...Object.entries(payload.select).filter(([, value]) => value).map(([field, value]) => {
@@ -1356,7 +1360,7 @@ var SqliteCrudDialect = class extends BaseCrudDialect {
             } else {
               return [
                 import_kysely3.sql.lit(field),
-                buildFieldRef(this.schema, relationModel, field, this.options, eb)
+                this.fieldRef(relationModel, field, eb)
               ];
             }
           }
@@ -2763,7 +2767,7 @@ var BaseOperationHandler = class {
         query = query.distinctOn(distinct.map((f) => import_kysely8.sql.ref(`${model}.${f}`)));
       } else {
         inMemoryDistinct = distinct;
-        query = distinct.reduce((acc, field) => acc.select((eb) => buildFieldRef(this.schema, model, field, this.options, eb).as(`$distinct$${field}`)), query);
+        query = distinct.reduce((acc, field) => acc.select((eb) => this.dialect.fieldRef(model, field, eb).as(`$distinct$${field}`)), query);
       }
     }
     if (args && "select" in args && args.select) {
@@ -3436,7 +3440,7 @@ ${compiled.parameters.map((p) => (0, import_node_util.inspect)(p)).join("\n")}`;
     const key = Object.keys(payload)[0];
     const value = this.dialect.transformPrimitive(payload[key], fieldDef.type, false);
     const eb = (0, import_kysely8.expressionBuilder)();
-    const fieldRef = buildFieldRef(this.schema, model, field, this.options, eb);
+    const fieldRef = this.dialect.fieldRef(model, field, eb);
     return (0, import_ts_pattern9.match)(key).with("set", () => value).with("increment", () => eb(fieldRef, "+", value)).with("decrement", () => eb(fieldRef, "-", value)).with("multiply", () => eb(fieldRef, "*", value)).with("divide", () => eb(fieldRef, "/", value)).otherwise(() => {
       throw new InternalError(`Invalid incremental update operation: ${key}`);
     });
@@ -3446,7 +3450,7 @@ ${compiled.parameters.map((p) => (0, import_node_util.inspect)(p)).join("\n")}`;
     const key = Object.keys(payload)[0];
     const value = this.dialect.transformPrimitive(payload[key], fieldDef.type, true);
     const eb = (0, import_kysely8.expressionBuilder)();
-    const fieldRef = buildFieldRef(this.schema, model, field, this.options, eb);
+    const fieldRef = this.dialect.fieldRef(model, field, eb);
     return (0, import_ts_pattern9.match)(key).with("set", () => value).with("push", () => {
       return eb(fieldRef, "||", eb.val(ensureArray(value)));
     }).otherwise(() => {
@@ -4320,10 +4324,11 @@ var GroupByOperationHandler = class extends BaseOperationHandler {
       subQuery = this.dialect.buildOrderBy(subQuery, this.model, this.model, void 0, skip !== void 0 || take !== void 0, negateOrderBy);
       return subQuery.as("$sub");
     });
+    const fieldRef = /* @__PURE__ */ __name((field) => this.dialect.fieldRef(this.model, field, (0, import_kysely11.expressionBuilder)(), "$sub"), "fieldRef");
     const bys = typeof parsedArgs.by === "string" ? [
       parsedArgs.by
     ] : parsedArgs.by;
-    query = query.groupBy(bys.map((by) => import_kysely11.sql.ref(`$sub.${by}`)));
+    query = query.groupBy(bys.map((by) => fieldRef(by)));
     if (parsedArgs.orderBy) {
       query = this.dialect.buildOrderBy(query, this.model, "$sub", parsedArgs.orderBy, false, false);
     }
@@ -4331,7 +4336,7 @@ var GroupByOperationHandler = class extends BaseOperationHandler {
       query = query.having((eb) => this.dialect.buildFilter(eb, this.model, "$sub", parsedArgs.having));
     }
     for (const by of bys) {
-      query = query.select(() => import_kysely11.sql.ref(`$sub.${by}`).as(by));
+      query = query.select(() => fieldRef(by).as(by));
     }
     for (const [key, value] of Object.entries(parsedArgs)) {
       switch (key) {
@@ -4344,7 +4349,7 @@ var GroupByOperationHandler = class extends BaseOperationHandler {
                 if (field === "_all") {
                   query = query.select((eb) => eb.cast(eb.fn.countAll(), "integer").as(`_count._all`));
                 } else {
-                  query = query.select((eb) => eb.cast(eb.fn.count(import_kysely11.sql.ref(`$sub.${field}`)), "integer").as(`${key}.${field}`));
+                  query = query.select((eb) => eb.cast(eb.fn.count(fieldRef(field)), "integer").as(`${key}.${field}`));
                 }
               }
             });
@@ -4357,10 +4362,7 @@ var GroupByOperationHandler = class extends BaseOperationHandler {
         case "_min": {
           Object.entries(value).forEach(([field, val]) => {
             if (val === true) {
-              query = query.select((eb) => {
-                const fn = (0, import_ts_pattern13.match)(key).with("_sum", () => eb.fn.sum).with("_avg", () => eb.fn.avg).with("_max", () => eb.fn.max).with("_min", () => eb.fn.min).exhaustive();
-                return fn(import_kysely11.sql.ref(`$sub.${field}`)).as(`${key}.${field}`);
-              });
+              query = query.select((eb) => aggregate(eb, fieldRef(field), key).as(`${key}.${field}`));
             }
           });
           break;
@@ -6288,6 +6290,7 @@ __name(processCasing, "processCasing");
 // src/client/helpers/schema-db-pusher.ts
 var import_common_helpers11 = require("@zenstackhq/common-helpers");
 var import_kysely15 = require("kysely");
+var import_toposort = __toESM(require("toposort"), 1);
 var import_ts_pattern18 = require("ts-pattern");
 var SchemaDbPusher = class {
   static {
@@ -6307,41 +6310,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 (0, import_toposort.default)(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)) {
       (0, import_common_helpers11.invariant)(typeof value === "object", "expecting an object");
       if ("type" in value) {
@@ -6349,17 +6390,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();
       }