@zenstackhq/orm 3.1.1 → 3.2.0

package/dist/index.js

@@ -617,6 +617,7 @@ import { match as match5 } from "ts-pattern";
 import { invariant as invariant3 } from "@zenstackhq/common-helpers";
 import Decimal from "decimal.js";
 import { sql as sql2 } from "kysely";
+import { parse as parsePostgresArray } from "postgres-array";
 import { match as match3 } from "ts-pattern";
 import z from "zod";
 
@@ -664,7 +665,7 @@ var BaseCrudDialect = class {
   transformPrimitive(value, _type, _forArrayField) {
     return value;
   }
-  transformOutput(value, _type) {
+  transformOutput(value, _type, _array) {
     return value;
   }
   // #region common query builders
@@ -1521,6 +1522,9 @@ var PostgresCrudDialect = class extends BaseCrudDialect {
     } else if (Array.isArray(value)) {
       if (type === "Json" && !forArrayField) {
         return JSON.stringify(value);
+      }
+      if (isEnum(this.schema, type)) {
+        return this.eb.cast(sql2`ARRAY[${sql2.join(value.map((v) => this.transformPrimitive(v, type, false)), sql2.raw(","))}]`, this.createSchemaQualifiedEnumType(type, true));
       } else {
         return value.map((v) => this.transformPrimitive(v, type, false));
       }
@@ -1534,11 +1538,29 @@ var PostgresCrudDialect = class extends BaseCrudDialect {
       }).otherwise(() => value);
     }
   }
-  transformOutput(value, type) {
+  createSchemaQualifiedEnumType(type, array) {
+    let qualified = type;
+    const enumDef = getEnum(this.schema, type);
+    if (enumDef) {
+      const schemaAttr = enumDef.attributes?.find((attr) => attr.name === "@@schema");
+      if (schemaAttr) {
+        const mapArg = schemaAttr.args?.find((arg) => arg.name === "map");
+        if (mapArg && mapArg.value.kind === "literal") {
+          const schemaName = mapArg.value.value;
+          qualified = `"${schemaName}"."${type}"`;
+        }
+      } else {
+        const defaultSchema = this.schema.provider.defaultSchema ?? "public";
+        qualified = `"${defaultSchema}"."${type}"`;
+      }
+    }
+    return array ? sql2.raw(`${qualified}[]`) : sql2.raw(qualified);
+  }
+  transformOutput(value, type, array) {
     if (value === null || value === void 0) {
       return value;
     }
-    return match3(type).with("DateTime", () => this.transformOutputDate(value)).with("Bytes", () => this.transformOutputBytes(value)).with("BigInt", () => this.transformOutputBigInt(value)).with("Decimal", () => this.transformDecimal(value)).otherwise(() => super.transformOutput(value, type));
+    return match3(type).with("DateTime", () => this.transformOutputDate(value)).with("Bytes", () => this.transformOutputBytes(value)).with("BigInt", () => this.transformOutputBigInt(value)).with("Decimal", () => this.transformDecimal(value)).when((type2) => isEnum(this.schema, type2), () => this.transformOutputEnum(value, array)).otherwise(() => super.transformOutput(value, type, array));
   }
   transformOutputBigInt(value) {
     if (typeof value === "bigint") {
@@ -1571,6 +1593,15 @@ var PostgresCrudDialect = class extends BaseCrudDialect {
   transformOutputBytes(value) {
     return Buffer.isBuffer(value) ? Uint8Array.from(value) : typeof value === "string" && value.startsWith("\\x") ? Uint8Array.from(Buffer.from(value.slice(2), "hex")) : value;
   }
+  transformOutputEnum(value, array) {
+    if (array && typeof value === "string") {
+      try {
+        return parsePostgresArray(value);
+      } catch {
+      }
+    }
+    return value;
+  }
   buildRelationSelection(query, model, relationField, parentAlias, payload) {
     const relationResultName = `${parentAlias}$${relationField}`;
     const joinedQuery = this.buildRelationJSON(model, query, relationField, parentAlias, payload, relationResultName);
@@ -1801,13 +1832,13 @@ var SqliteCrudDialect = class extends BaseCrudDialect {
       return match4(type).with("Boolean", () => value ? 1 : 0).with("DateTime", () => value instanceof Date ? value.toISOString() : typeof value === "string" ? new Date(value).toISOString() : value).with("Decimal", () => value.toString()).with("Bytes", () => Buffer.from(value)).otherwise(() => value);
     }
   }
-  transformOutput(value, type) {
+  transformOutput(value, type, array) {
     if (value === null || value === void 0) {
       return value;
     } else if (this.schema.typeDefs && type in this.schema.typeDefs) {
       return this.transformOutputJson(value);
     } else {
-      return match4(type).with("Boolean", () => this.transformOutputBoolean(value)).with("DateTime", () => this.transformOutputDate(value)).with("Bytes", () => this.transformOutputBytes(value)).with("Decimal", () => this.transformOutputDecimal(value)).with("BigInt", () => this.transformOutputBigInt(value)).with("Json", () => this.transformOutputJson(value)).otherwise(() => super.transformOutput(value, type));
+      return match4(type).with("Boolean", () => this.transformOutputBoolean(value)).with("DateTime", () => this.transformOutputDate(value)).with("Bytes", () => this.transformOutputBytes(value)).with("Decimal", () => this.transformOutputDecimal(value)).with("BigInt", () => this.transformOutputBigInt(value)).with("Json", () => this.transformOutputJson(value)).otherwise(() => super.transformOutput(value, type, array));
     }
   }
   transformOutputDecimal(value) {
@@ -2087,6 +2118,21 @@ var BaseOperationHandler = class {
       select: this.makeIdSelect(model)
     });
   }
+  async existsNonUnique(kysely, model, filter) {
+    const query = kysely.selectNoFrom((eb) => eb.exists(this.dialect.buildSelectModel(model, model).select(sql4.lit(1).as("$t")).where(() => this.dialect.buildFilter(model, model, filter))).as("exists")).modifyEnd(this.makeContextComment({
+      model,
+      operation: "read"
+    }));
+    let result = [];
+    const compiled = kysely.getExecutor().compileQuery(query.toOperationNode(), createQueryId());
+    try {
+      const r = await kysely.getExecutor().executeQuery(compiled);
+      result = r.rows;
+    } catch (err) {
+      throw createDBQueryError(`Failed to execute query: ${err}`, err, compiled.sql, compiled.parameters);
+    }
+    return !!result[0]?.exists;
+  }
   async read(kysely, model, args) {
     let query = this.dialect.buildSelectModel(model, model);
     if (args) {
@@ -2110,7 +2156,7 @@ var BaseOperationHandler = class {
       const r = await kysely.getExecutor().executeQuery(compiled);
       result = r.rows;
     } catch (err) {
-      throw createDBQueryError("Failed to execute query", err, compiled.sql, compiled.parameters);
+      throw createDBQueryError(`Failed to execute query: ${err}`, err, compiled.sql, compiled.parameters);
     }
     return result;
   }
@@ -3698,6 +3744,18 @@ var FindOperationHandler = class extends BaseOperationHandler {
   }
 };
 
+// src/client/crud/operations/exists.ts
+var ExistsOperationHandler = class extends BaseOperationHandler {
+  static {
+    __name(this, "ExistsOperationHandler");
+  }
+  async handle(_operation, args) {
+    const normalizedArgs = this.normalizeArgs(args);
+    const parsedArgs = this.inputValidator.validateExistsArgs(this.model, normalizedArgs);
+    return await this.existsNonUnique(this.client.$qb, this.model, parsedArgs?.where);
+  }
+};
+
 // src/client/crud/operations/group-by.ts
 import { match as match10 } from "ts-pattern";
 var GroupByOperationHandler = class extends BaseOperationHandler {
@@ -4314,9 +4372,96 @@ var InputValidator = class {
   get extraValidationsEnabled() {
     return this.client.$options.validateInput !== false;
   }
+  validateProcedureInput(proc, input) {
+    const procDef = (this.schema.procedures ?? {})[proc];
+    invariant7(procDef, `Procedure "${proc}" not found in schema`);
+    const params = Object.values(procDef.params ?? {});
+    if (typeof input === "undefined") {
+      if (params.length === 0) {
+        return void 0;
+      }
+      if (params.every((p) => p.optional)) {
+        return void 0;
+      }
+      throw createInvalidInputError("Missing procedure arguments", `$procs.${proc}`);
+    }
+    if (typeof input !== "object") {
+      throw createInvalidInputError("Procedure input must be an object", `$procs.${proc}`);
+    }
+    const envelope = input;
+    const argsPayload = Object.prototype.hasOwnProperty.call(envelope, "args") ? envelope.args : void 0;
+    if (params.length === 0) {
+      if (typeof argsPayload === "undefined") {
+        return input;
+      }
+      if (!argsPayload || typeof argsPayload !== "object" || Array.isArray(argsPayload)) {
+        throw createInvalidInputError("Procedure `args` must be an object", `$procs.${proc}`);
+      }
+      if (Object.keys(argsPayload).length === 0) {
+        return input;
+      }
+      throw createInvalidInputError("Procedure does not accept arguments", `$procs.${proc}`);
+    }
+    if (typeof argsPayload === "undefined") {
+      if (params.every((p) => p.optional)) {
+        return input;
+      }
+      throw createInvalidInputError("Missing procedure arguments", `$procs.${proc}`);
+    }
+    if (!argsPayload || typeof argsPayload !== "object" || Array.isArray(argsPayload)) {
+      throw createInvalidInputError("Procedure `args` must be an object", `$procs.${proc}`);
+    }
+    const obj = argsPayload;
+    for (const param of params) {
+      const value = obj[param.name];
+      if (!Object.prototype.hasOwnProperty.call(obj, param.name)) {
+        if (param.optional) {
+          continue;
+        }
+        throw createInvalidInputError(`Missing procedure argument: ${param.name}`, `$procs.${proc}`);
+      }
+      if (typeof value === "undefined") {
+        if (param.optional) {
+          continue;
+        }
+        throw createInvalidInputError(`Invalid procedure argument: ${param.name} is required`, `$procs.${proc}`);
+      }
+      const schema = this.makeProcedureParamSchema(param);
+      const parsed = schema.safeParse(value);
+      if (!parsed.success) {
+        throw createInvalidInputError(`Invalid procedure argument: ${param.name}: ${formatError(parsed.error)}`, `$procs.${proc}`);
+      }
+    }
+    return input;
+  }
+  makeProcedureParamSchema(param) {
+    let schema;
+    if (isTypeDef(this.schema, param.type)) {
+      schema = this.makeTypeDefSchema(param.type);
+    } else if (isEnum(this.schema, param.type)) {
+      schema = this.makeEnumSchema(param.type);
+    } else if (param.type in (this.schema.models ?? {})) {
+      schema = z3.record(z3.string(), z3.unknown());
+    } else {
+      schema = this.makeScalarSchema(param.type);
+      if (schema instanceof z3.ZodUnknown) {
+        throw createInternalError(`Unsupported procedure parameter type: ${param.type}`);
+      }
+    }
+    if (param.array) {
+      schema = schema.array();
+    }
+    if (param.optional) {
+      schema = schema.optional();
+    }
+    return schema;
+  }
   validateFindArgs(model, args, options) {
     return this.validate(model, "find", options, (model2, options2) => this.makeFindSchema(model2, options2), args);
   }
+  validateExistsArgs(model, args) {
+    return this.validate(model, "exists", void 0, (model2) => this.makeExistsSchema(model2), args);
+  }
   validateCreateArgs(model, args) {
     return this.validate(model, "create", void 0, (model2) => this.makeCreateSchema(model2), args);
   }
@@ -4421,6 +4566,11 @@ var InputValidator = class {
     }
     return result;
   }
+  makeExistsSchema(model) {
+    return z3.strictObject({
+      where: this.makeWhereSchema(model, false).optional()
+    }).optional();
+  }
   makeScalarSchema(type, attributes) {
     if (this.schema.typeDefs && type in this.schema.typeDefs) {
       return this.makeTypeDefSchema(type);
@@ -4525,7 +4675,7 @@ var InputValidator = class {
         const enumDef = getEnum(this.schema, fieldDef.type);
         if (enumDef) {
           if (Object.keys(enumDef.values).length > 0) {
-            fieldSchema = this.makeEnumFilterSchema(enumDef, !!fieldDef.optional, withAggregations);
+            fieldSchema = this.makeEnumFilterSchema(enumDef, !!fieldDef.optional, withAggregations, !!fieldDef.array);
           }
         } else if (fieldDef.array) {
           fieldSchema = this.makeArrayFilterSchema(fieldDef.type);
@@ -4549,7 +4699,7 @@ var InputValidator = class {
             const enumDef = getEnum(this.schema, def.type);
             if (enumDef) {
               if (Object.keys(enumDef.values).length > 0) {
-                fieldSchema = this.makeEnumFilterSchema(enumDef, !!def.optional, false);
+                fieldSchema = this.makeEnumFilterSchema(enumDef, !!def.optional, false, false);
               } else {
                 fieldSchema = z3.never();
               }
@@ -4599,15 +4749,13 @@ var InputValidator = class {
         if (this.isTypeDefType(fieldDef.type)) {
           fieldSchemas[fieldName] = this.makeTypedJsonFilterSchema(fieldDef.type, !!fieldDef.optional, !!fieldDef.array).optional();
         } else {
-          if (fieldDef.array) {
+          const enumDef = getEnum(this.schema, fieldDef.type);
+          if (enumDef) {
+            fieldSchemas[fieldName] = this.makeEnumFilterSchema(enumDef, !!fieldDef.optional, false, !!fieldDef.array).optional();
+          } else if (fieldDef.array) {
             fieldSchemas[fieldName] = this.makeArrayFilterSchema(fieldDef.type).optional();
           } else {
-            const enumDef = getEnum(this.schema, fieldDef.type);
-            if (enumDef) {
-              fieldSchemas[fieldName] = this.makeEnumFilterSchema(enumDef, !!fieldDef.optional, false).optional();
-            } else {
-              fieldSchemas[fieldName] = this.makePrimitiveFilterSchema(fieldDef.type, !!fieldDef.optional, false).optional();
-            }
+            fieldSchemas[fieldName] = this.makePrimitiveFilterSchema(fieldDef.type, !!fieldDef.optional, false).optional();
           }
         }
       }
@@ -4635,9 +4783,12 @@ var InputValidator = class {
   isTypeDefType(type) {
     return this.schema.typeDefs && type in this.schema.typeDefs;
   }
-  makeEnumFilterSchema(enumDef, optional, withAggregations) {
+  makeEnumFilterSchema(enumDef, optional, withAggregations, array) {
     const baseSchema = z3.enum(Object.keys(enumDef.values));
-    const components = this.makeCommonPrimitiveFilterComponents(baseSchema, optional, () => z3.lazy(() => this.makeEnumFilterSchema(enumDef, optional, withAggregations)), [
+    if (array) {
+      return this.internalMakeArrayFilterSchema(baseSchema);
+    }
+    const components = this.makeCommonPrimitiveFilterComponents(baseSchema, optional, () => z3.lazy(() => this.makeEnumFilterSchema(enumDef, optional, withAggregations, array)), [
       "equals",
       "in",
       "notIn",
@@ -4653,11 +4804,14 @@ var InputValidator = class {
     ]);
   }
   makeArrayFilterSchema(type) {
+    return this.internalMakeArrayFilterSchema(this.makeScalarSchema(type));
+  }
+  internalMakeArrayFilterSchema(elementSchema) {
     return z3.strictObject({
-      equals: this.makeScalarSchema(type).array().optional(),
-      has: this.makeScalarSchema(type).optional(),
-      hasEvery: this.makeScalarSchema(type).array().optional(),
-      hasSome: this.makeScalarSchema(type).array().optional(),
+      equals: elementSchema.array().optional(),
+      has: elementSchema.optional(),
+      hasEvery: elementSchema.array().optional(),
+      hasSome: elementSchema.array().optional(),
       isEmpty: z3.boolean().optional()
     });
   }
@@ -5717,14 +5871,16 @@ var QueryNameMapper = class extends OperationNodeTransformer {
       return super.transformSelectQuery(node);
     }
     const processedFroms = node.from.froms.map((from) => this.processSelectTable(from));
-    const processedJoins = this.withScopes([
+    const processedJoins = [];
+    const cumulativeScopes = [
       ...processedFroms.map(({ scope }) => scope)
-    ], () => (node.joins ?? []).map((join) => this.processSelectTable(join.table)));
-    const scopes = [
-      ...processedFroms.map(({ scope }) => scope),
-      ...processedJoins.map(({ scope }) => scope)
     ];
-    return this.withScopes(scopes, () => {
+    for (const join of node.joins ?? []) {
+      const processedJoin = this.withScopes(cumulativeScopes, () => this.processSelectTable(join.table));
+      processedJoins.push(processedJoin);
+      cumulativeScopes.push(processedJoin.scope);
+    }
+    return this.withScopes(cumulativeScopes, () => {
       const joins = node.joins ? node.joins.map((join, i) => ({
         ...join,
         table: processedJoins[i].node,
@@ -6059,9 +6215,9 @@ var QueryNameMapper = class extends OperationNodeTransformer {
     let schema = this.schema.provider.defaultSchema ?? "public";
     const schemaAttr = this.schema.models[model]?.attributes?.find((attr) => attr.name === "@@schema");
     if (schemaAttr) {
-      const nameArg = schemaAttr.args?.find((arg) => arg.name === "map");
-      if (nameArg && nameArg.value.kind === "literal") {
-        schema = nameArg.value.value;
+      const mapArg = schemaAttr.args?.find((arg) => arg.name === "map");
+      if (mapArg && mapArg.value.kind === "literal") {
+        schema = mapArg.value.value;
       }
     }
     return schema;
@@ -6312,7 +6468,7 @@ var ZenStackQueryExecutor = class _ZenStackQueryExecutor extends DefaultQueryExe
         if (err instanceof ORMError) {
           throw err;
         } else {
-          throw createDBQueryError("Failed to execute query", err, compiledQuery.sql, compiledQuery.parameters);
+          throw createDBQueryError(`Failed to execute query: ${err}`, err, compiledQuery.sql, compiledQuery.parameters);
         }
       }
     });
@@ -6552,7 +6708,7 @@ var ZenStackQueryExecutor = class _ZenStackQueryExecutor extends DefaultQueryExe
     try {
       return await connection.executeQuery(compiledQuery);
     } catch (err) {
-      throw createDBQueryError("Failed to execute query", err, compiledQuery.sql, compiledQuery.parameters);
+      throw createDBQueryError(`Failed to execute query: ${err}`, err, compiledQuery.sql, compiledQuery.parameters);
     }
   }
 };
@@ -7010,7 +7166,7 @@ var ResultProcessor = class {
       }
       if (key.startsWith(DELEGATE_JOINED_FIELD_PREFIX)) {
         if (value) {
-          const subRow = this.dialect.transformOutput(value, "Json");
+          const subRow = this.dialect.transformOutput(value, "Json", false);
           const subModel = key.slice(DELEGATE_JOINED_FIELD_PREFIX.length);
           const idValues = getIdValues(this.schema, subModel, subRow);
           if (Object.values(idValues).some((v) => v === null || v === void 0)) {
@@ -7044,10 +7200,10 @@ var ResultProcessor = class {
   processFieldValue(value, fieldDef) {
     const type = fieldDef.type;
     if (Array.isArray(value)) {
-      value.forEach((v, i) => value[i] = this.dialect.transformOutput(v, type));
+      value.forEach((v, i) => value[i] = this.dialect.transformOutput(v, type, false));
       return value;
     } else {
-      return this.dialect.transformOutput(value, type);
+      return this.dialect.transformOutput(value, type, !!fieldDef.array);
     }
   }
   processRelation(value, fieldDef) {
@@ -7205,24 +7361,54 @@ var ClientImpl = class _ClientImpl {
       return txBuilder.execute((tx) => execute(tx));
     }
   }
-  get $procedures() {
+  get $procs() {
     return Object.keys(this.$schema.procedures ?? {}).reduce((acc, name) => {
-      acc[name] = (...args) => this.handleProc(name, args);
+      acc[name] = (input) => this.handleProc(name, input);
       return acc;
     }, {});
   }
-  async handleProc(name, args) {
+  async handleProc(name, input) {
     if (!("procedures" in this.$options) || !this.$options || typeof this.$options.procedures !== "object") {
       throw createConfigError("Procedures are not configured for the client.");
     }
+    const procDef = (this.$schema.procedures ?? {})[name];
+    if (!procDef) {
+      throw createConfigError(`Procedure "${name}" is not defined in schema.`);
+    }
     const procOptions = this.$options.procedures;
     if (!procOptions[name] || typeof procOptions[name] !== "function") {
-      throw new Error(`Procedure "${name}" does not have a handler configured.`);
-    }
-    return procOptions[name].apply(this, [
-      this,
-      ...args
-    ]);
+      throw createConfigError(`Procedure "${name}" does not have a handler configured.`);
+    }
+    const inputValidator = new InputValidator(this);
+    const validatedInput = inputValidator.validateProcedureInput(name, input);
+    const handler = procOptions[name];
+    const invokeWithClient = /* @__PURE__ */ __name(async (client, _input) => {
+      let proceed = /* @__PURE__ */ __name(async (nextInput) => {
+        const sanitizedNextInput = nextInput && typeof nextInput === "object" && !Array.isArray(nextInput) ? nextInput : {};
+        return handler({
+          client,
+          ...sanitizedNextInput
+        });
+      }, "proceed");
+      const plugins = [
+        ...client.$options?.plugins ?? []
+      ];
+      for (const plugin of plugins) {
+        const onProcedure = plugin.onProcedure;
+        if (onProcedure) {
+          const _proceed = proceed;
+          proceed = /* @__PURE__ */ __name((nextInput) => onProcedure({
+            client,
+            name,
+            mutation: !!procDef.mutation,
+            input: nextInput,
+            proceed: /* @__PURE__ */ __name((finalInput) => _proceed(finalInput), "proceed")
+          }), "proceed");
+        }
+      }
+      return proceed(_input);
+    }, "invokeWithClient");
+    return invokeWithClient(this, validatedInput);
   }
   async $connect() {
     await this.kysely.connection().execute(async (conn) => {
@@ -7429,7 +7615,10 @@ function createModelCrudHandler(client, model, inputValidator, resultProcessor)
     }, "aggregate"),
     groupBy: /* @__PURE__ */ __name((args) => {
       return createPromise("groupBy", "groupBy", args, new GroupByOperationHandler(client, model, inputValidator), true);
-    }, "groupBy")
+    }, "groupBy"),
+    exists: /* @__PURE__ */ __name((args) => {
+      return createPromise("exists", "exists", args, new ExistsOperationHandler(client, model, inputValidator), false);
+    }, "exists")
   };
 }
 __name(createModelCrudHandler, "createModelCrudHandler");
@@ -7860,6 +8049,7 @@ export {
   CRUD_EXT,
   DbNull,
   DbNullClass,
+  InputValidator,
   JsonNull,
   JsonNullClass,
   kysely_utils_exports as KyselyUtils,