@zenstackhq/orm 3.4.5 → 3.5.0-beta.1

package/dist/index.js

@@ -20,6 +20,14 @@ var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "defau
 // src/client/client-impl.ts
 import { invariant as invariant14, lowerCaseFirst as lowerCaseFirst3 } from "@zenstackhq/common-helpers";
 import { CompiledQuery, DefaultConnectionProvider, DefaultQueryExecutor as DefaultQueryExecutor2, Kysely, Log, sql as sql8, Transaction } from "kysely";
+import z2 from "zod";
+
+// src/utils/zod-utils.ts
+import { fromError } from "zod-validation-error/v4";
+function formatError(error) {
+  return fromError(error).toString();
+}
+__name(formatError, "formatError");
 
 // src/client/crud/operations/aggregate.ts
 import { match as match8 } from "ts-pattern";
@@ -1171,16 +1179,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 || !isPlainObject(payload)) {
       return {
         conditions: [
-          this.buildLiteralFilter(lhs, type, payload)
+          this.buildValueFilter(lhs, type, payload)
         ],
         consumedKeys: []
       };
@@ -1934,7 +1948,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;
@@ -3137,7 +3154,7 @@ var BaseOperationHandler = class {
         const length = firstArgVal;
         const generated = typeof length === "number" ? nanoid(length) : nanoid();
         return this.formatGeneratedValue(generated, defaultValue.args?.[1]);
-      }).with("ulid", () => this.formatGeneratedValue(ulid(), defaultValue.args?.[0])).otherwise(() => void 0);
+      }).with("ulid", () => this.formatGeneratedValue(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) {
@@ -4618,13 +4635,6 @@ var UpdateOperationHandler = class extends BaseOperationHandler {
 import { invariant as invariant9 } from "@zenstackhq/common-helpers";
 import { match as match14 } from "ts-pattern";
 
-// src/utils/zod-utils.ts
-import { fromError } from "zod-validation-error/v4";
-function formatError(error) {
-  return fromError(error).toString();
-}
-__name(formatError, "formatError");
-
 // src/client/zod/factory.ts
 import { enumerate as enumerate3, invariant as invariant8, lowerCaseFirst } from "@zenstackhq/common-helpers";
 import { ZodUtils } from "@zenstackhq/zod";
@@ -4676,6 +4686,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);
 }
@@ -4690,6 +4709,7 @@ var ZodSchemaFactory = class {
   ];
   schema;
   options;
+  extraValidationsEnabled = true;
   constructor(clientOrSchema, options) {
     if ("$schema" in clientOrSchema) {
       this.schema = clientOrSchema.$schema;
@@ -4702,9 +4722,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;
   }
@@ -4725,14 +4742,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
@@ -4880,14 +4896,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) {
@@ -4904,12 +4920,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 = z.never();
               }
             } else {
-              fieldSchema = this.makePrimitiveFilterSchema(model, def, false, true);
+              fieldSchema = this.makePrimitiveFilterSchema(model, toFieldInfo(def), false, true);
             }
             return [
               key,
@@ -4956,15 +4972,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();
           }
         }
       }
@@ -6548,9 +6564,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) {
@@ -6597,6 +6615,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];
     invariant9(procDef, `Procedure "${proc}" not found in schema`);
     const params = Object.values(procDef.params ?? {});
@@ -6661,6 +6682,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) {
@@ -7495,6 +7519,7 @@ var TempAliasTransformer = class extends OperationNodeTransformer2 {
 };
 
 // src/client/executor/zenstack-query-executor.ts
+var DEFAULT_MAX_SLOW_RECORDS = 100;
 var ZenStackQueryExecutor = class _ZenStackQueryExecutor extends DefaultQueryExecutor {
   static {
     __name(this, "ZenStackQueryExecutor");
@@ -7911,13 +7936,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)) {
@@ -8064,7 +8125,7 @@ var isEmpty = /* @__PURE__ */ __name((eb, args, { dialect }) => {
   }
   return eb(dialect.buildArrayLength(field), "=", sql6.lit(0));
 }, "isEmpty");
-var now = /* @__PURE__ */ __name(() => sql6.raw("CURRENT_TIMESTAMP"), "now");
+var now = /* @__PURE__ */ __name((_eb, _args, context) => match16(context.dialect.provider).with("sqlite", () => sql6.raw("strftime('%Y-%m-%dT%H:%M:%fZ')")).with("mysql", () => sql6.raw("CONCAT(SUBSTRING(DATE_FORMAT(UTC_TIMESTAMP(3), '%Y-%m-%dT%H:%i:%s.%f'), 1, 23), '+00:00')")).with("postgresql", () => sql6.raw("CURRENT_TIMESTAMP")).exhaustive(), "now");
 var currentModel = /* @__PURE__ */ __name((_eb, args, { model }) => {
   let result = model;
   const [casing] = args;
@@ -8589,6 +8650,7 @@ var ClientImpl = class _ClientImpl {
   kyselyProps;
   auth;
   inputValidator;
+  slowQueries = [];
   constructor(schema, options, baseClient, executor) {
     this.schema = schema;
     this.options = options;
@@ -8598,9 +8660,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,
@@ -8608,6 +8668,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 Log(this.$options.log ?? []));
       const compiler = options.dialect.createQueryCompiler();
@@ -8628,32 +8689,31 @@ var ClientImpl = class _ClientImpl {
       });
     }
     this.kysely = new 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 = z2.object({
+        slowQueryThresholdMs: z2.number().nonnegative().optional(),
+        slowQueryMaxRecords: z2.int().nonnegative().or(z2.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)) {
@@ -8669,6 +8729,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) {
     invariant14(typeof input === "function" || Array.isArray(input) && input.every((p) => p.then && p.cb), "Invalid transaction input, expected a function or an array of ZenStackPromise");
@@ -8790,7 +8868,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) {
@@ -8805,7 +8885,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() {
@@ -8814,7 +8896,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) {
@@ -8830,7 +8914,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) {
@@ -8840,6 +8926,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 sql8(query, ...values).execute(this.kysely);