@zenstackhq/runtime 3.0.0-beta.10 → 3.0.0-beta.11

package/dist/index.cjs

@@ -62,7 +62,6 @@ var import_ts_pattern7 = require("ts-pattern");
 var query_utils_exports = {};
 __export(query_utils_exports, {
   aggregate: () => aggregate,
-  buildFieldRef: () => buildFieldRef,
   buildJoinPairs: () => buildJoinPairs,
   ensureArray: () => ensureArray,
   extractFieldName: () => extractFieldName,
@@ -408,28 +407,6 @@ function getIdValues(schema, model, data) {
   }), {});
 }
 __name(getIdValues, "getIdValues");
-function buildFieldRef(schema, model, field, options, eb, modelAlias, inlineComputedField = true) {
-  const fieldDef = requireField(schema, model, field);
-  if (!fieldDef.computed) {
-    return eb.ref(modelAlias ? `${modelAlias}.${field}` : field);
-  } else {
-    if (!inlineComputedField) {
-      return eb.ref(modelAlias ? `${modelAlias}.${field}` : field);
-    }
-    let computer;
-    if ("computedFields" in options) {
-      const computedFields = options.computedFields;
-      computer = computedFields?.[model]?.[field];
-    }
-    if (!computer) {
-      throw new QueryError(`Computed field "${field}" implementation not provided for model "${model}"`);
-    }
-    return computer(eb, {
-      modelAlias
-    });
-  }
-}
-__name(buildFieldRef, "buildFieldRef");
 function fieldHasDefaultValue(fieldDef) {
   return fieldDef.default !== void 0 || fieldDef.updatedAt;
 }
@@ -781,7 +758,7 @@ var BaseCrudDialect = class {
       take = -take;
     }
     result = this.buildSkipTake(result, skip, take);
-    result = this.buildOrderBy(result, model, modelAlias, args.orderBy, skip !== void 0 || take !== void 0, negateOrderBy);
+    result = this.buildOrderBy(result, model, modelAlias, args.orderBy, negateOrderBy);
     if ("distinct" in args && args.distinct) {
       const distinct = ensureArray(args.distinct);
       if (this.supportsDistinctOn) {
@@ -1140,16 +1117,12 @@ var BaseCrudDialect = class {
     ]);
     return this.and(...conditions.conditions);
   }
-  buildOrderBy(query, model, modelAlias, orderBy, useDefaultIfEmpty, negated) {
+  buildOrderBy(query, model, modelAlias, orderBy, negated) {
     if (!orderBy) {
-      if (useDefaultIfEmpty) {
-        orderBy = makeDefaultOrderBy(this.schema, model);
-      } else {
-        return query;
-      }
+      return query;
     }
     let result = query;
-    const buildFieldRef2 = /* @__PURE__ */ __name((model2, field, modelAlias2) => {
+    const buildFieldRef = /* @__PURE__ */ __name((model2, field, modelAlias2) => {
       const fieldDef = requireField(this.schema, model2, field);
       return fieldDef.originModel ? this.fieldRef(fieldDef.originModel, field, fieldDef.originModel) : this.fieldRef(model2, field, modelAlias2);
     }, "buildFieldRef");
@@ -1168,7 +1141,7 @@ var BaseCrudDialect = class {
           (0, import_common_helpers3.invariant)(value && typeof value === "object", `invalid orderBy value for field "${field}"`);
           for (const [k, v] of Object.entries(value)) {
             (0, import_common_helpers3.invariant)(v === "asc" || v === "desc", `invalid orderBy value for field "${field}"`);
-            result = result.orderBy((eb) => aggregate(eb, buildFieldRef2(model, k, modelAlias), field), import_kysely2.sql.raw(this.negateSort(v, negated)));
+            result = result.orderBy((eb) => aggregate(eb, buildFieldRef(model, k, modelAlias), field), import_kysely2.sql.raw(this.negateSort(v, negated)));
           }
           continue;
         }
@@ -1177,7 +1150,7 @@ var BaseCrudDialect = class {
             (0, import_common_helpers3.invariant)(value && typeof value === "object", 'invalid orderBy value for field "_count"');
             for (const [k, v] of Object.entries(value)) {
               (0, import_common_helpers3.invariant)(v === "asc" || v === "desc", `invalid orderBy value for field "${field}"`);
-              result = result.orderBy((eb) => eb.fn.count(buildFieldRef2(model, k, modelAlias)), import_kysely2.sql.raw(this.negateSort(v, negated)));
+              result = result.orderBy((eb) => eb.fn.count(buildFieldRef(model, k, modelAlias)), import_kysely2.sql.raw(this.negateSort(v, negated)));
             }
             continue;
           }
@@ -1186,7 +1159,7 @@ var BaseCrudDialect = class {
         }
         const fieldDef = requireField(this.schema, model, field);
         if (!fieldDef.relation) {
-          const fieldRef = buildFieldRef2(model, field, modelAlias);
+          const fieldRef = buildFieldRef(model, field, modelAlias);
           if (value === "asc" || value === "desc") {
             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")) {
@@ -1215,7 +1188,7 @@ var BaseCrudDialect = class {
               const joinPairs = buildJoinPairs(this.schema, model, modelAlias, field, relationModel);
               return join.on((eb) => this.and(...joinPairs.map(([left, right]) => eb(this.eb.ref(left), "=", this.eb.ref(right)))));
             });
-            result = this.buildOrderBy(result, fieldDef.type, relationModel, value, false, negated);
+            result = this.buildOrderBy(result, fieldDef.type, relationModel, value, negated);
           }
         }
       }
@@ -1262,13 +1235,9 @@ var BaseCrudDialect = class {
   }
   buildSelectField(query, model, modelAlias, field) {
     const fieldDef = requireField(this.schema, model, field);
-    if (fieldDef.computed) {
-      return query.select(() => this.fieldRef(model, field, modelAlias).as(field));
-    } else if (!fieldDef.originModel) {
-      return query.select(this.eb.ref(`${modelAlias}.${field}`).as(field));
-    } else {
-      return this.buildSelectField(query, fieldDef.originModel, fieldDef.originModel, field);
-    }
+    const fieldModel = fieldDef.originModel ?? model;
+    const alias = fieldDef.originModel ?? modelAlias;
+    return query.select(() => this.fieldRef(fieldModel, field, alias).as(field));
   }
   buildDelegateJoin(thisModel, thisModelAlias, otherModelAlias, query) {
     const idFields = requireIdFields(this.schema, thisModel);
@@ -1357,7 +1326,25 @@ var BaseCrudDialect = class {
     return this.eb.not(this.and(...args));
   }
   fieldRef(model, field, modelAlias, inlineComputedField = true) {
-    return buildFieldRef(this.schema, model, field, this.options, this.eb, modelAlias, inlineComputedField);
+    const fieldDef = requireField(this.schema, model, field);
+    if (!fieldDef.computed) {
+      return this.eb.ref(modelAlias ? `${modelAlias}.${field}` : field);
+    } else {
+      if (!inlineComputedField) {
+        return this.eb.ref(modelAlias ? `${modelAlias}.${field}` : field);
+      }
+      let computer;
+      if ("computedFields" in this.options) {
+        const computedFields = this.options.computedFields;
+        computer = computedFields?.[fieldDef.originModel ?? model]?.[field];
+      }
+      if (!computer) {
+        throw new QueryError(`Computed field "${field}" implementation not provided for model "${model}"`);
+      }
+      return computer(this.eb, {
+        modelAlias
+      });
+    }
   }
   canJoinWithoutNestedSelect(modelDef, payload) {
     if (modelDef.computedFields) {
@@ -3201,7 +3188,7 @@ var AggregateOperationHandler = class extends BaseOperationHandler {
         take = -take;
       }
       subQuery = this.dialect.buildSkipTake(subQuery, skip, take);
-      subQuery = this.dialect.buildOrderBy(subQuery, this.model, this.model, parsedArgs.orderBy, skip !== void 0 || take !== void 0, negateOrderBy);
+      subQuery = this.dialect.buildOrderBy(subQuery, this.model, this.model, parsedArgs.orderBy, negateOrderBy);
       return subQuery.as("$sub");
     });
     for (const [key, value] of Object.entries(parsedArgs)) {
@@ -3432,29 +3419,23 @@ var GroupByOperationHandler = class extends BaseOperationHandler {
   async handle(_operation, args) {
     const normalizedArgs = this.normalizeArgs(args);
     const parsedArgs = this.inputValidator.validateGroupByArgs(this.model, normalizedArgs);
-    let query = this.kysely.selectFrom((eb) => {
-      let subQuery = eb.selectFrom(this.model).selectAll().where(() => this.dialect.buildFilter(this.model, this.model, parsedArgs?.where));
-      const skip = parsedArgs?.skip;
-      let take = parsedArgs?.take;
-      let negateOrderBy = false;
-      if (take !== void 0 && take < 0) {
-        negateOrderBy = true;
-        take = -take;
-      }
-      subQuery = this.dialect.buildSkipTake(subQuery, skip, take);
-      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, "$sub"), "fieldRef");
+    let query = this.kysely.selectFrom(this.model).where(() => this.dialect.buildFilter(this.model, this.model, parsedArgs?.where));
+    const fieldRef = /* @__PURE__ */ __name((field) => this.dialect.fieldRef(this.model, field), "fieldRef");
     const bys = typeof parsedArgs.by === "string" ? [
       parsedArgs.by
     ] : parsedArgs.by;
     query = query.groupBy(bys.map((by) => fieldRef(by)));
-    if (parsedArgs.orderBy) {
-      query = this.dialect.buildOrderBy(query, this.model, "$sub", parsedArgs.orderBy, false, false);
+    const skip = parsedArgs?.skip;
+    let take = parsedArgs?.take;
+    let negateOrderBy = false;
+    if (take !== void 0 && take < 0) {
+      negateOrderBy = true;
+      take = -take;
     }
+    query = this.dialect.buildSkipTake(query, skip, take);
+    query = this.dialect.buildOrderBy(query, this.model, this.model, parsedArgs.orderBy, negateOrderBy);
     if (parsedArgs.having) {
-      query = query.having(() => this.dialect.buildFilter(this.model, "$sub", parsedArgs.having));
+      query = query.having(() => this.dialect.buildFilter(this.model, this.model, parsedArgs.having));
     }
     for (const by of bys) {
       query = query.select(() => fieldRef(by).as(by));
@@ -3978,12 +3959,12 @@ function evalCall(data, expr) {
 __name(evalCall, "evalCall");
 
 // src/client/crud/validator/index.ts
+var schemaCache = /* @__PURE__ */ new WeakMap();
 var InputValidator = class {
   static {
     __name(this, "InputValidator");
   }
   client;
-  schemaCache = /* @__PURE__ */ new Map();
   constructor(client) {
     this.client = client;
   }
@@ -4032,16 +4013,34 @@ var InputValidator = class {
   validateGroupByArgs(model, args) {
     return this.validate(model, "groupBy", void 0, (model2) => this.makeGroupBySchema(model2), args);
   }
+  getSchemaCache(cacheKey) {
+    let thisCache = schemaCache.get(this.schema);
+    if (!thisCache) {
+      thisCache = /* @__PURE__ */ new Map();
+      schemaCache.set(this.schema, thisCache);
+    }
+    return thisCache.get(cacheKey);
+  }
+  setSchemaCache(cacheKey, schema) {
+    let thisCache = schemaCache.get(this.schema);
+    if (!thisCache) {
+      thisCache = /* @__PURE__ */ new Map();
+      schemaCache.set(this.schema, thisCache);
+    }
+    return thisCache.set(cacheKey, schema);
+  }
   validate(model, operation, options, getSchema, args) {
     const cacheKey = (0, import_json_stable_stringify.default)({
+      type: "model",
       model,
       operation,
-      options
+      options,
+      extraValidationsEnabled: this.extraValidationsEnabled
     });
-    let schema = this.schemaCache.get(cacheKey);
+    let schema = this.getSchemaCache(cacheKey);
     if (!schema) {
       schema = getSchema(model, options);
-      this.schemaCache.set(cacheKey, schema);
+      this.setSchemaCache(cacheKey, schema);
     }
     const { error, data } = schema.safeParse(args);
     if (error) {
@@ -4100,8 +4099,12 @@ var InputValidator = class {
     }
   }
   makeTypeDefSchema(type) {
-    const key = `$typedef-${type}`;
-    let schema = this.schemaCache.get(key);
+    const key = (0, import_json_stable_stringify.default)({
+      type: "typedef",
+      name: type,
+      extraValidationsEnabled: this.extraValidationsEnabled
+    });
+    let schema = this.getSchemaCache(key);
     if (schema) {
       return schema;
     }
@@ -4120,7 +4123,7 @@ var InputValidator = class {
         fieldSchema
       ];
     }))).passthrough();
-    this.schemaCache.set(key, schema);
+    this.setSchemaCache(key, schema);
     return schema;
   }
   makeWhereSchema(model, unique, withoutRelationFields = false, withAggregations = false) {
@@ -5569,7 +5572,18 @@ var ZenStackQueryExecutor = class _ZenStackQueryExecutor extends import_kysely7.
   nameMapper;
   constructor(client, driver, compiler, adapter, connectionProvider, plugins = [], suppressMutationHooks = false) {
     super(compiler, adapter, connectionProvider, plugins), this.client = client, this.driver = driver, this.compiler = compiler, this.connectionProvider = connectionProvider, this.suppressMutationHooks = suppressMutationHooks;
-    this.nameMapper = new QueryNameMapper(client.$schema);
+    if (this.schemaHasMappedNames(client.$schema)) {
+      this.nameMapper = new QueryNameMapper(client.$schema);
+    }
+  }
+  schemaHasMappedNames(schema) {
+    const hasMapAttr = /* @__PURE__ */ __name((decl) => {
+      if (decl.attributes?.some((attr) => attr.name === "@@map")) {
+        return true;
+      }
+      return Object.values(decl.fields).some((field) => field.attributes?.some((attr) => attr.name === "@map"));
+    }, "hasMapAttr");
+    return Object.values(schema.models).some(hasMapAttr) || Object.values(schema.typeDefs ?? []).some(hasMapAttr);
   }
   get kysely() {
     return this.client.$qb;
@@ -5651,7 +5665,7 @@ var ZenStackQueryExecutor = class _ZenStackQueryExecutor extends import_kysely7.
   async proceedQuery(connection, query, parameters, queryId) {
     let compiled;
     if (this.suppressMutationHooks || !this.isMutationNode(query) || !this.hasEntityMutationPlugins) {
-      const finalQuery2 = this.nameMapper.transformNode(query);
+      const finalQuery2 = this.processNameMapping(query);
       compiled = this.compileQuery(finalQuery2);
       if (parameters) {
         compiled = {
@@ -5669,7 +5683,7 @@ var ZenStackQueryExecutor = class _ZenStackQueryExecutor extends import_kysely7.
         ])
       };
     }
-    const finalQuery = this.nameMapper.transformNode(query);
+    const finalQuery = this.processNameMapping(query);
     compiled = this.compileQuery(finalQuery);
     if (parameters) {
       compiled = {
@@ -5697,6 +5711,9 @@ var ZenStackQueryExecutor = class _ZenStackQueryExecutor extends import_kysely7.
     }
     return result;
   }
+  processNameMapping(query) {
+    return this.nameMapper?.transformNode(query) ?? query;
+  }
   createClientForConnection(connection, inTx) {
     const innerExecutor = this.withConnectionProvider(new import_kysely7.SingleConnectionProvider(connection));
     innerExecutor.suppressMutationHooks = true;
@@ -6481,6 +6498,11 @@ var ClientImpl = class _ClientImpl {
       ...args
     ]);
   }
+  async $connect() {
+    await this.kysely.connection().execute(async (conn) => {
+      await conn.executeQuery(import_kysely10.sql`select 1`.compile(this.kysely));
+    });
+  }
   async $disconnect() {
     await this.kysely.destroy();
   }