@zenstackhq/orm 3.4.5 → 3.5.0-beta.1

package/dist/index.cjs

@@ -67,6 +67,14 @@ module.exports = __toCommonJS(src_exports);
 // src/client/client-impl.ts
 var import_common_helpers14 = require("@zenstackhq/common-helpers");
 var import_kysely12 = require("kysely");
+var import_zod3 = __toESM(require("zod"), 1);
+
+// src/utils/zod-utils.ts
+var import_v4 = require("zod-validation-error/v4");
+function formatError(error) {
+  return (0, import_v4.fromError)(error).toString();
+}
+__name(formatError, "formatError");
 
 // src/client/crud/operations/aggregate.ts
 var import_ts_pattern8 = require("ts-pattern");
@@ -1217,16 +1225,22 @@ var BaseCrudDialect = class {
     }
   }
   buildJsonEqualityFilter(lhs, rhs) {
-    return this.buildLiteralFilter(lhs, "Json", rhs);
+    return this.buildValueFilter(lhs, "Json", rhs);
   }
-  buildLiteralFilter(lhs, type, rhs) {
-    return this.eb(lhs, "=", rhs !== null && rhs !== void 0 ? this.transformInput(rhs, type, false) : rhs);
+  buildValueFilter(lhs, type, rhs) {
+    if (rhs === void 0) {
+      return this.true();
+    }
+    if (rhs === null) {
+      return this.eb(lhs, "is", null);
+    }
+    return this.eb(lhs, "=", this.transformInput(rhs, type, false));
   }
   buildStandardFilter(type, payload, lhs, getRhs, recurse, throwIfInvalid = false, onlyForKeys = void 0, excludeKeys = []) {
     if (payload === null || !(0, import_common_helpers2.isPlainObject)(payload)) {
       return {
         conditions: [
-          this.buildLiteralFilter(lhs, type, payload)
+          this.buildValueFilter(lhs, type, payload)
         ],
         consumedKeys: []
       };
@@ -1980,7 +1994,10 @@ var PostgresCrudDialect = class _PostgresCrudDialect extends LateralJoinDialectB
   overrideTypeParsers() {
     if (this.options.fixPostgresTimezone !== false && !_PostgresCrudDialect.typeParserOverrideApplied) {
       _PostgresCrudDialect.typeParserOverrideApplied = true;
-      import("pg").then((pg) => {
+      import(
+        /* webpackIgnore: true */
+        "pg"
+      ).then((pg) => {
         pg.types.setTypeParser(pg.types.builtins.TIMESTAMP, (value) => {
           if (typeof value !== "string") {
             return value;
@@ -3183,7 +3200,7 @@ var BaseOperationHandler = class {
         const length = firstArgVal;
         const generated = typeof length === "number" ? (0, import_nanoid.nanoid)(length) : (0, import_nanoid.nanoid)();
         return this.formatGeneratedValue(generated, defaultValue.args?.[1]);
-      }).with("ulid", () => this.formatGeneratedValue((0, import_ulid.ulid)(), defaultValue.args?.[0])).otherwise(() => void 0);
+      }).with("ulid", () => this.formatGeneratedValue((0, import_ulid.ulid)(), defaultValue.args?.[0])).with("now", () => /* @__PURE__ */ new Date()).otherwise(() => void 0);
     } else if (schema_exports.ExpressionUtils.isMember(defaultValue) && schema_exports.ExpressionUtils.isCall(defaultValue.receiver) && defaultValue.receiver.function === "auth") {
       let val = this.client.$auth;
       for (const member of defaultValue.members) {
@@ -4664,13 +4681,6 @@ var UpdateOperationHandler = class extends BaseOperationHandler {
 var import_common_helpers9 = require("@zenstackhq/common-helpers");
 var import_ts_pattern14 = require("ts-pattern");
 
-// src/utils/zod-utils.ts
-var import_v4 = require("zod-validation-error/v4");
-function formatError(error) {
-  return (0, import_v4.fromError)(error).toString();
-}
-__name(formatError, "formatError");
-
 // src/client/zod/factory.ts
 var import_common_helpers8 = require("@zenstackhq/common-helpers");
 var import_zod = require("@zenstackhq/zod");
@@ -4722,6 +4732,15 @@ function _ts_metadata(k, v) {
   if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 }
 __name(_ts_metadata, "_ts_metadata");
+function toFieldInfo(def) {
+  return {
+    name: def.name,
+    type: def.type,
+    optional: def.optional,
+    array: def.array
+  };
+}
+__name(toFieldInfo, "toFieldInfo");
 function createQuerySchemaFactory(clientOrSchema, options) {
   return new ZodSchemaFactory(clientOrSchema, options);
 }
@@ -4736,6 +4755,7 @@ var ZodSchemaFactory = class {
   ];
   schema;
   options;
+  extraValidationsEnabled = true;
   constructor(clientOrSchema, options) {
     if ("$schema" in clientOrSchema) {
       this.schema = clientOrSchema.$schema;
@@ -4748,9 +4768,6 @@ var ZodSchemaFactory = class {
   get plugins() {
     return this.options.plugins ?? [];
   }
-  get extraValidationsEnabled() {
-    return this.options.validateInput !== false;
-  }
   shouldIncludeRelations(options) {
     return options?.relationDepth === void 0 || options.relationDepth > 0;
   }
@@ -4771,14 +4788,13 @@ var ZodSchemaFactory = class {
   setCache(cacheKey, schema) {
     return this.schemaCache.set(cacheKey, schema);
   }
-  // @ts-ignore
-  printCacheStats(detailed = false) {
-    console.log("Schema cache size:", this.schemaCache.size);
-    if (detailed) {
-      for (const key of this.schemaCache.keys()) {
-        console.log(`	${key}`);
-      }
-    }
+  get cacheStats() {
+    return {
+      size: this.schemaCache.size,
+      keys: [
+        ...this.schemaCache.keys()
+      ]
+    };
   }
   // #endregion
   // #region Find
@@ -4926,14 +4942,14 @@ var ZodSchemaFactory = class {
         const enumDef = getEnum(this.schema, fieldDef.type);
         if (enumDef) {
           if (Object.keys(enumDef.values).length > 0) {
-            fieldSchema = this.makeEnumFilterSchema(model, fieldDef, withAggregations, ignoreSlicing);
+            fieldSchema = this.makeEnumFilterSchema(model, toFieldInfo(fieldDef), withAggregations, ignoreSlicing);
           }
         } else if (fieldDef.array) {
-          fieldSchema = this.makeArrayFilterSchema(model, fieldDef);
+          fieldSchema = this.makeArrayFilterSchema(model, toFieldInfo(fieldDef));
         } else if (this.isTypeDefType(fieldDef.type)) {
-          fieldSchema = this.makeTypedJsonFilterSchema(model, fieldDef);
+          fieldSchema = this.makeTypedJsonFilterSchema(model, toFieldInfo(fieldDef));
         } else {
-          fieldSchema = this.makePrimitiveFilterSchema(model, fieldDef, withAggregations, ignoreSlicing);
+          fieldSchema = this.makePrimitiveFilterSchema(model, toFieldInfo(fieldDef), withAggregations, ignoreSlicing);
         }
       }
       if (fieldSchema) {
@@ -4950,12 +4966,12 @@ var ZodSchemaFactory = class {
             const enumDef = getEnum(this.schema, def.type);
             if (enumDef) {
               if (Object.keys(enumDef.values).length > 0) {
-                fieldSchema = this.makeEnumFilterSchema(model, def, false, true);
+                fieldSchema = this.makeEnumFilterSchema(model, toFieldInfo(def), false, true);
               } else {
                 fieldSchema = import_zod2.z.never();
               }
             } else {
-              fieldSchema = this.makePrimitiveFilterSchema(model, def, false, true);
+              fieldSchema = this.makePrimitiveFilterSchema(model, toFieldInfo(def), false, true);
             }
             return [
               key,
@@ -5002,15 +5018,15 @@ var ZodSchemaFactory = class {
       const fieldSchemas = {};
       for (const [fieldName, fieldDef] of Object.entries(typeDef.fields)) {
         if (this.isTypeDefType(fieldDef.type)) {
-          fieldSchemas[fieldName] = this.makeTypedJsonFilterSchema(contextModel, fieldDef).optional();
+          fieldSchemas[fieldName] = this.makeTypedJsonFilterSchema(contextModel, toFieldInfo(fieldDef)).optional();
         } else {
           const enumDef = getEnum(this.schema, fieldDef.type);
           if (enumDef) {
-            fieldSchemas[fieldName] = this.makeEnumFilterSchema(contextModel, fieldDef, false).optional();
+            fieldSchemas[fieldName] = this.makeEnumFilterSchema(contextModel, toFieldInfo(fieldDef), false).optional();
           } else if (fieldDef.array) {
-            fieldSchemas[fieldName] = this.makeArrayFilterSchema(contextModel, fieldDef).optional();
+            fieldSchemas[fieldName] = this.makeArrayFilterSchema(contextModel, toFieldInfo(fieldDef)).optional();
           } else {
-            fieldSchemas[fieldName] = this.makePrimitiveFilterSchema(contextModel, fieldDef, false).optional();
+            fieldSchemas[fieldName] = this.makePrimitiveFilterSchema(contextModel, toFieldInfo(fieldDef), false).optional();
           }
         }
       }
@@ -6594,9 +6610,11 @@ var InputValidator = class {
   }
   client;
   zodFactory;
-  constructor(client) {
+  enabled;
+  constructor(client, options) {
     this.client = client;
     this.zodFactory = new ZodSchemaFactory(client);
+    this.enabled = options?.enabled !== false;
   }
   // #region Entry points
   validateFindArgs(model, args, operation) {
@@ -6643,6 +6661,9 @@ var InputValidator = class {
   }
   // TODO: turn it into a Zod schema and cache
   validateProcedureInput(proc, input) {
+    if (!this.enabled) {
+      return input;
+    }
     const procDef = (this.client.$schema.procedures ?? {})[proc];
     (0, import_common_helpers9.invariant)(procDef, `Procedure "${proc}" not found in schema`);
     const params = Object.values(procDef.params ?? {});
@@ -6707,6 +6728,9 @@ var InputValidator = class {
   // #endregion
   // #region Validation helpers
   validate(model, operation, getSchema, args) {
+    if (!this.enabled) {
+      return args;
+    }
     const schema = getSchema(model);
     const { error, data } = schema.safeParse(args);
     if (error) {
@@ -7541,6 +7565,7 @@ var TempAliasTransformer = class extends import_kysely8.OperationNodeTransformer
 };
 
 // src/client/executor/zenstack-query-executor.ts
+var DEFAULT_MAX_SLOW_RECORDS = 100;
 var ZenStackQueryExecutor = class _ZenStackQueryExecutor extends import_kysely9.DefaultQueryExecutor {
   static {
     __name(this, "ZenStackQueryExecutor");
@@ -7957,13 +7982,49 @@ In such cases, ZenStack cannot reliably determine the IDs of the mutated entitie
         parameters
       };
     }
+    const trackSlowQuery = this.options.diagnostics !== void 0;
+    const startTimestamp = trackSlowQuery ? performance.now() : void 0;
+    const startedAt = trackSlowQuery ? /* @__PURE__ */ new Date() : void 0;
     try {
       const result = await connection.executeQuery(compiledQuery);
+      if (startTimestamp !== void 0) {
+        this.trackSlowQuery(compiledQuery, startTimestamp, startedAt);
+      }
       return this.ensureProperQueryResult(compiledQuery.query, result);
     } catch (err) {
       throw createDBQueryError(`Failed to execute query: ${err}`, err, compiledQuery.sql, compiledQuery.parameters);
     }
   }
+  trackSlowQuery(compiledQuery, startTimestamp, startedAt) {
+    const durationMs = performance.now() - startTimestamp;
+    const thresholdMs = this.options.diagnostics?.slowQueryThresholdMs;
+    if (thresholdMs === void 0 || durationMs < thresholdMs) {
+      return;
+    }
+    const slowQueries = this.client.slowQueries;
+    const maxRecords = this.options.diagnostics?.slowQueryMaxRecords ?? DEFAULT_MAX_SLOW_RECORDS;
+    if (maxRecords <= 0) {
+      return;
+    }
+    const queryInfo = {
+      startedAt,
+      durationMs,
+      sql: compiledQuery.sql
+    };
+    if (slowQueries.length >= maxRecords) {
+      let minIndex = 0;
+      for (let i = 1; i < slowQueries.length; i++) {
+        if (slowQueries[i].durationMs < slowQueries[minIndex].durationMs) {
+          minIndex = i;
+        }
+      }
+      if (durationMs > slowQueries[minIndex].durationMs) {
+        slowQueries[minIndex] = queryInfo;
+      }
+    } else {
+      slowQueries.push(queryInfo);
+    }
+  }
   ensureProperQueryResult(query, result) {
     let finalResult = result;
     if (this.isMutationNode(query)) {
@@ -8110,7 +8171,7 @@ var isEmpty = /* @__PURE__ */ __name((eb, args, { dialect }) => {
   }
   return eb(dialect.buildArrayLength(field), "=", import_kysely10.sql.lit(0));
 }, "isEmpty");
-var now = /* @__PURE__ */ __name(() => import_kysely10.sql.raw("CURRENT_TIMESTAMP"), "now");
+var now = /* @__PURE__ */ __name((_eb, _args, context) => (0, import_ts_pattern16.match)(context.dialect.provider).with("sqlite", () => import_kysely10.sql.raw("strftime('%Y-%m-%dT%H:%M:%fZ')")).with("mysql", () => import_kysely10.sql.raw("CONCAT(SUBSTRING(DATE_FORMAT(UTC_TIMESTAMP(3), '%Y-%m-%dT%H:%i:%s.%f'), 1, 23), '+00:00')")).with("postgresql", () => import_kysely10.sql.raw("CURRENT_TIMESTAMP")).exhaustive(), "now");
 var currentModel = /* @__PURE__ */ __name((_eb, args, { model }) => {
   let result = model;
   const [casing] = args;
@@ -8635,6 +8696,7 @@ var ClientImpl = class _ClientImpl {
   kyselyProps;
   auth;
   inputValidator;
+  slowQueries = [];
   constructor(schema, options, baseClient, executor) {
     this.schema = schema;
     this.options = options;
@@ -8644,9 +8706,7 @@ var ClientImpl = class _ClientImpl {
       ...functions_exports,
       ...this.$options.functions
     };
-    if (!baseClient && !options.skipValidationForComputedFields) {
-      this.validateComputedFieldsConfig();
-    }
+    this.validateOptions(baseClient, options);
     if (baseClient) {
       this.kyselyProps = {
         ...baseClient.kyselyProps,
@@ -8654,6 +8714,7 @@ var ClientImpl = class _ClientImpl {
       };
       this.kyselyRaw = baseClient.kyselyRaw;
       this.auth = baseClient.auth;
+      this.slowQueries = baseClient.slowQueries;
     } else {
       const driver = new ZenStackDriver(options.dialect.createDriver(), new import_kysely12.Log(this.$options.log ?? []));
       const compiler = options.dialect.createQueryCompiler();
@@ -8674,32 +8735,31 @@ var ClientImpl = class _ClientImpl {
       });
     }
     this.kysely = new import_kysely12.Kysely(this.kyselyProps);
-    this.inputValidator = baseClient?.inputValidator ?? new InputValidator(this);
+    this.inputValidator = baseClient?.inputValidator ?? new InputValidator(this, {
+      enabled: this.$options.validateInput !== false
+    });
     return createClientProxy(this);
   }
-  get $qb() {
-    return this.kysely;
-  }
-  get $qbRaw() {
-    return this.kyselyRaw;
-  }
-  get $zod() {
-    return this.inputValidator.zodFactory;
-  }
-  get isTransaction() {
-    return this.kysely.isTransaction;
-  }
-  /**
-   * Create a new client with a new query executor.
-   */
-  withExecutor(executor) {
-    return new _ClientImpl(this.schema, this.$options, this, executor);
+  validateOptions(baseClient, options) {
+    if (!baseClient && !options.skipValidationForComputedFields) {
+      this.validateComputedFieldsConfig(options);
+    }
+    if (options.diagnostics) {
+      const diagnosticsSchema = import_zod3.default.object({
+        slowQueryThresholdMs: import_zod3.default.number().nonnegative().optional(),
+        slowQueryMaxRecords: import_zod3.default.int().nonnegative().or(import_zod3.default.literal(Infinity)).optional()
+      });
+      const parseResult = diagnosticsSchema.safeParse(options.diagnostics);
+      if (!parseResult.success) {
+        throw createConfigError(`Invalid diagnostics configuration: ${formatError(parseResult.error)}`);
+      }
+    }
   }
   /**
    * Validates that all computed fields in the schema have corresponding configurations.
    */
-  validateComputedFieldsConfig() {
-    const computedFieldsConfig = "computedFields" in this.$options ? this.$options.computedFields : void 0;
+  validateComputedFieldsConfig(options) {
+    const computedFieldsConfig = "computedFields" in options ? options.computedFields : void 0;
     for (const [modelName, modelDef] of Object.entries(this.$schema.models)) {
       if (modelDef.computedFields) {
         for (const fieldName of Object.keys(modelDef.computedFields)) {
@@ -8715,6 +8775,24 @@ var ClientImpl = class _ClientImpl {
       }
     }
   }
+  get $qb() {
+    return this.kysely;
+  }
+  get $qbRaw() {
+    return this.kyselyRaw;
+  }
+  get $zod() {
+    return this.inputValidator.zodFactory;
+  }
+  get isTransaction() {
+    return this.kysely.isTransaction;
+  }
+  /**
+   * Create a new client with a new query executor.
+   */
+  withExecutor(executor) {
+    return new _ClientImpl(this.schema, this.$options, this, executor);
+  }
   // implementation
   async $transaction(input, options) {
     (0, import_common_helpers14.invariant)(typeof input === "function" || Array.isArray(input) && input.every((p) => p.then && p.cb), "Invalid transaction input, expected a function or an array of ZenStackPromise");
@@ -8836,7 +8914,9 @@ var ClientImpl = class _ClientImpl {
       plugins: newPlugins
     };
     const newClient = new _ClientImpl(this.schema, newOptions, this);
-    newClient.inputValidator = new InputValidator(newClient);
+    newClient.inputValidator = new InputValidator(newClient, {
+      enabled: newOptions.validateInput !== false
+    });
     return newClient;
   }
   $unuse(pluginId) {
@@ -8851,7 +8931,9 @@ var ClientImpl = class _ClientImpl {
       plugins: newPlugins
     };
     const newClient = new _ClientImpl(this.schema, newOptions, this);
-    newClient.inputValidator = new InputValidator(newClient);
+    newClient.inputValidator = new InputValidator(newClient, {
+      enabled: newClient.$options.validateInput !== false
+    });
     return newClient;
   }
   $unuseAll() {
@@ -8860,7 +8942,9 @@ var ClientImpl = class _ClientImpl {
       plugins: []
     };
     const newClient = new _ClientImpl(this.schema, newOptions, this);
-    newClient.inputValidator = new InputValidator(newClient);
+    newClient.inputValidator = new InputValidator(newClient, {
+      enabled: newOptions.validateInput !== false
+    });
     return newClient;
   }
   $setAuth(auth) {
@@ -8876,7 +8960,9 @@ var ClientImpl = class _ClientImpl {
   }
   $setOptions(options) {
     const newClient = new _ClientImpl(this.schema, options, this);
-    newClient.inputValidator = new InputValidator(newClient);
+    newClient.inputValidator = new InputValidator(newClient, {
+      enabled: newClient.$options.validateInput !== false
+    });
     return newClient;
   }
   $setInputValidation(enable) {
@@ -8886,6 +8972,14 @@ var ClientImpl = class _ClientImpl {
     };
     return this.$setOptions(newOptions);
   }
+  async $diagnostics() {
+    return {
+      zodCache: this.inputValidator.zodFactory.cacheStats,
+      slowQueries: this.slowQueries.map((q) => ({
+        ...q
+      }))
+    };
+  }
   $executeRaw(query, ...values) {
     return createZenStackPromise(async () => {
       const result = await (0, import_kysely12.sql)(query, ...values).execute(this.kysely);