@zenstackhq/zod 3.4.0-beta.4 → 3.4.1

package/dist/index.js

@@ -1,31 +1,650 @@
 var __defProp = Object.defineProperty;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/factory.ts
+import { ExpressionUtils as ExpressionUtils2, SchemaAccessor } from "@zenstackhq/schema";
+import Decimal2 from "decimal.js";
+import z2 from "zod";
+
+// src/error.ts
+var SchemaFactoryError = class extends Error {
+  static {
+    __name(this, "SchemaFactoryError");
+  }
+  constructor(message) {
+    super(message);
+  }
+};
 
-// src/index.ts
-import { match, P } from "ts-pattern";
+// src/utils.ts
+var utils_exports = {};
+__export(utils_exports, {
+  addBigIntValidation: () => addBigIntValidation,
+  addCustomValidation: () => addCustomValidation,
+  addDecimalValidation: () => addDecimalValidation,
+  addListValidation: () => addListValidation,
+  addNumberValidation: () => addNumberValidation,
+  addStringValidation: () => addStringValidation
+});
+import { ExpressionUtils } from "@zenstackhq/schema";
+import Decimal from "decimal.js";
 import { z } from "zod";
-function makeSelectSchema(schema, model) {
-  return z.strictObject(mapFields(schema, model));
+function getArgValue(expr) {
+  if (!expr || !ExpressionUtils.isLiteral(expr)) {
+    return void 0;
+  }
+  return expr.value;
+}
+__name(getArgValue, "getArgValue");
+function addStringValidation(schema, attributes) {
+  if (!attributes || attributes.length === 0) {
+    return schema;
+  }
+  let result = schema;
+  for (const attr of attributes) {
+    switch (attr.name) {
+      case "@length": {
+        const min = getArgValue(attr.args?.[0]?.value);
+        if (min !== void 0) {
+          result = result.min(min);
+        }
+        const max = getArgValue(attr.args?.[1]?.value);
+        if (max !== void 0) {
+          result = result.max(max);
+        }
+        break;
+      }
+      case "@startsWith": {
+        const value = getArgValue(attr.args?.[0]?.value);
+        if (value !== void 0) {
+          result = result.startsWith(value);
+        }
+        break;
+      }
+      case "@endsWith": {
+        const value = getArgValue(attr.args?.[0]?.value);
+        if (value !== void 0) {
+          result = result.endsWith(value);
+        }
+        break;
+      }
+      case "@contains": {
+        const value = getArgValue(attr.args?.[0]?.value);
+        if (value !== void 0) {
+          result = result.includes(value);
+        }
+        break;
+      }
+      case "@regex": {
+        const pattern = getArgValue(attr.args?.[0]?.value);
+        if (pattern !== void 0) {
+          result = result.regex(new RegExp(pattern));
+        }
+        break;
+      }
+      case "@email":
+        result = result.email();
+        break;
+      case "@datetime":
+        result = result.datetime();
+        break;
+      case "@url":
+        result = result.url();
+        break;
+      case "@trim":
+        result = result.trim();
+        break;
+      case "@lower":
+        result = result.toLowerCase();
+        break;
+      case "@upper":
+        result = result.toUpperCase();
+        break;
+    }
+  }
+  return result;
+}
+__name(addStringValidation, "addStringValidation");
+function addNumberValidation(schema, attributes) {
+  if (!attributes || attributes.length === 0) {
+    return schema;
+  }
+  let result = schema;
+  for (const attr of attributes) {
+    const val = getArgValue(attr.args?.[0]?.value);
+    if (val === void 0) {
+      continue;
+    }
+    switch (attr.name) {
+      case "@gt":
+        result = result.gt(val);
+        break;
+      case "@gte":
+        result = result.gte(val);
+        break;
+      case "@lt":
+        result = result.lt(val);
+        break;
+      case "@lte":
+        result = result.lte(val);
+        break;
+    }
+  }
+  return result;
 }
-__name(makeSelectSchema, "makeSelectSchema");
-function mapFields(schema, model) {
-  const modelDef = schema.models[model];
-  if (!modelDef) {
-    throw new Error(`Model ${model} not found in schema`);
+__name(addNumberValidation, "addNumberValidation");
+function addBigIntValidation(schema, attributes) {
+  if (!attributes || attributes.length === 0) {
+    return schema;
   }
-  const scalarFields = Object.entries(modelDef.fields).filter(([_, fieldDef]) => !fieldDef.relation);
-  const result = {};
-  for (const [field, fieldDef] of scalarFields) {
-    result[field] = makeScalarSchema(fieldDef);
+  let result = schema;
+  for (const attr of attributes) {
+    const val = getArgValue(attr.args?.[0]?.value);
+    if (val === void 0) {
+      continue;
+    }
+    switch (attr.name) {
+      case "@gt":
+        result = result.gt(BigInt(val));
+        break;
+      case "@gte":
+        result = result.gte(BigInt(val));
+        break;
+      case "@lt":
+        result = result.lt(BigInt(val));
+        break;
+      case "@lte":
+        result = result.lte(BigInt(val));
+        break;
+    }
   }
   return result;
 }
-__name(mapFields, "mapFields");
-function makeScalarSchema(fieldDef) {
-  return match(fieldDef.type).with("String", () => z.string()).with(P.union("Int", "BigInt", "Float", "Decimal"), () => z.number()).with("Boolean", () => z.boolean()).with("DateTime", () => z.string().datetime()).otherwise(() => z.unknown());
+__name(addBigIntValidation, "addBigIntValidation");
+function addDecimalValidation(schema, attributes, addExtraValidation) {
+  let result = schema;
+  if (schema instanceof z.ZodString) {
+    result = schema.superRefine((v, ctx) => {
+      try {
+        new Decimal(v);
+      } catch (err) {
+        ctx.addIssue({
+          code: "custom",
+          message: `Invalid decimal: ${err}`
+        });
+      }
+    }).transform((val) => new Decimal(val));
+  }
+  function refine(schema2, op, value) {
+    return schema2.superRefine((v, ctx) => {
+      const base = z.number();
+      const { error } = base[op](value).safeParse(v.toNumber());
+      error?.issues.forEach((issue) => {
+        if (op === "gt" || op === "gte") {
+          ctx.addIssue({
+            code: "too_small",
+            origin: "number",
+            minimum: value,
+            type: "decimal",
+            inclusive: op === "gte",
+            message: issue.message
+          });
+        } else {
+          ctx.addIssue({
+            code: "too_big",
+            origin: "number",
+            maximum: value,
+            type: "decimal",
+            inclusive: op === "lte",
+            message: issue.message
+          });
+        }
+      });
+    });
+  }
+  __name(refine, "refine");
+  if (attributes && addExtraValidation) {
+    for (const attr of attributes) {
+      const val = getArgValue(attr.args?.[0]?.value);
+      if (val === void 0) {
+        continue;
+      }
+      switch (attr.name) {
+        case "@gt":
+          result = refine(result, "gt", val);
+          break;
+        case "@gte":
+          result = refine(result, "gte", val);
+          break;
+        case "@lt":
+          result = refine(result, "lt", val);
+          break;
+        case "@lte":
+          result = refine(result, "lte", val);
+          break;
+      }
+    }
+  }
+  return result;
+}
+__name(addDecimalValidation, "addDecimalValidation");
+function addListValidation(schema, attributes) {
+  if (!attributes || attributes.length === 0) {
+    return schema;
+  }
+  let result = schema;
+  for (const attr of attributes) {
+    if (attr.name === "@length") {
+      const min = getArgValue(attr.args?.[0]?.value);
+      if (min !== void 0) {
+        result = result.min(min);
+      }
+      const max = getArgValue(attr.args?.[1]?.value);
+      if (max !== void 0) {
+        result = result.max(max);
+      }
+    }
+  }
+  return result;
+}
+__name(addListValidation, "addListValidation");
+function addCustomValidation(schema, attributes) {
+  const attrs = attributes?.filter((a) => a.name === "@@validate");
+  if (!attrs || attrs.length === 0) {
+    return schema;
+  }
+  let result = schema;
+  for (const attr of attrs) {
+    const expr = attr.args?.[0]?.value;
+    if (!expr) {
+      continue;
+    }
+    const message = getArgValue(attr.args?.[1]?.value);
+    const pathExpr = attr.args?.[2]?.value;
+    let path = void 0;
+    if (pathExpr && ExpressionUtils.isArray(pathExpr)) {
+      path = pathExpr.items.map((e) => ExpressionUtils.getLiteralValue(e));
+    }
+    result = applyValidation(result, expr, message, path);
+  }
+  return result;
+}
+__name(addCustomValidation, "addCustomValidation");
+function applyValidation(schema, expr, message, path) {
+  const options = {};
+  if (message) {
+    options.error = message;
+  }
+  if (path) {
+    options.path = path;
+  }
+  return schema.refine((data) => Boolean(evalExpression(data, expr)), options);
+}
+__name(applyValidation, "applyValidation");
+function evalExpression(data, expr) {
+  switch (expr.kind) {
+    case "literal":
+      return expr.value;
+    case "array":
+      return expr.items.map((item) => evalExpression(data, item));
+    case "field":
+      return evalField(data, expr);
+    case "member":
+      return evalMember(data, expr);
+    case "unary":
+      return evalUnary(data, expr);
+    case "binary":
+      return evalBinary(data, expr);
+    case "call":
+      return evalCall(data, expr);
+    case "this":
+      return data ?? null;
+    case "null":
+      return null;
+    case "binding":
+      throw new SchemaFactoryError("Binding expression is not supported in validation expressions");
+  }
+}
+__name(evalExpression, "evalExpression");
+function evalField(data, e) {
+  return data?.[e.field] ?? null;
+}
+__name(evalField, "evalField");
+function evalUnary(data, expr) {
+  const operand = evalExpression(data, expr.operand);
+  switch (expr.op) {
+    case "!":
+      return !operand;
+    default:
+      throw new SchemaFactoryError(`Unsupported unary operator: ${expr.op}`);
+  }
+}
+__name(evalUnary, "evalUnary");
+function evalBinary(data, expr) {
+  const left = evalExpression(data, expr.left);
+  const right = evalExpression(data, expr.right);
+  switch (expr.op) {
+    case "&&":
+      return Boolean(left) && Boolean(right);
+    case "||":
+      return Boolean(left) || Boolean(right);
+    case "==":
+      return left == right;
+    case "!=":
+      return left != right;
+    case "<":
+      return left < right;
+    case "<=":
+      return left <= right;
+    case ">":
+      return left > right;
+    case ">=":
+      return left >= right;
+    case "?":
+      if (!Array.isArray(left)) {
+        return false;
+      }
+      return left.some((item) => item === right);
+    case "!":
+      if (!Array.isArray(left)) {
+        return false;
+      }
+      return left.every((item) => item === right);
+    case "^":
+      if (!Array.isArray(left)) {
+        return false;
+      }
+      return !left.some((item) => item === right);
+    case "in":
+      if (!Array.isArray(right)) {
+        return false;
+      }
+      return right.includes(left);
+    default:
+      throw new SchemaFactoryError(`Unsupported binary operator: ${expr.op}`);
+  }
 }
-__name(makeScalarSchema, "makeScalarSchema");
+__name(evalBinary, "evalBinary");
+function evalMember(data, expr) {
+  let result = evalExpression(data, expr.receiver);
+  for (const member of expr.members) {
+    if (!result || typeof result !== "object") {
+      return void 0;
+    }
+    result = result[member];
+  }
+  return result ?? null;
+}
+__name(evalMember, "evalMember");
+function evalCall(data, expr) {
+  const f = expr.function;
+  const fieldArg = expr.args?.[0] ? evalExpression(data, expr.args[0]) : void 0;
+  switch (f) {
+    // string functions
+    case "length": {
+      if (fieldArg === void 0 || fieldArg === null) {
+        return false;
+      }
+      invariant(typeof fieldArg === "string" || Array.isArray(fieldArg), `"${f}" first argument must be a string or a list`);
+      return fieldArg.length;
+    }
+    case "startsWith":
+    case "endsWith":
+    case "contains": {
+      if (fieldArg === void 0 || fieldArg === null) {
+        return false;
+      }
+      invariant(typeof fieldArg === "string", `"${f}" first argument must be a string`);
+      invariant(expr.args?.[1], `"${f}" requires a search argument`);
+      const search = getArgValue(expr.args?.[1]);
+      const caseInsensitive = getArgValue(expr.args?.[2]) ?? false;
+      const applyStringOp = /* @__PURE__ */ __name((x, y) => {
+        switch (f) {
+          case "startsWith":
+            return x.startsWith(y);
+          case "endsWith":
+            return x.endsWith(y);
+          case "contains":
+            return x.includes(y);
+        }
+      }, "applyStringOp");
+      return caseInsensitive ? applyStringOp(fieldArg.toLowerCase(), search.toLowerCase()) : applyStringOp(fieldArg, search);
+    }
+    case "regex": {
+      if (fieldArg === void 0 || fieldArg === null) {
+        return false;
+      }
+      invariant(typeof fieldArg === "string", `"${f}" first argument must be a string`);
+      const pattern = getArgValue(expr.args?.[1]);
+      invariant(pattern !== void 0, `"${f}" requires a pattern argument`);
+      return new RegExp(pattern).test(fieldArg);
+    }
+    case "isEmail":
+    case "isUrl":
+    case "isDateTime": {
+      if (fieldArg === void 0 || fieldArg === null) {
+        return false;
+      }
+      invariant(typeof fieldArg === "string", `"${f}" first argument must be a string`);
+      const fn = f === "isEmail" ? "email" : f === "isUrl" ? "url" : "datetime";
+      return z.string()[fn]().safeParse(fieldArg).success;
+    }
+    // list functions
+    case "has":
+    case "hasEvery":
+    case "hasSome": {
+      invariant(expr.args?.[1], `${f} requires a search argument`);
+      if (fieldArg === void 0 || fieldArg === null) {
+        return false;
+      }
+      invariant(Array.isArray(fieldArg), `"${f}" first argument must be an array field`);
+      const search = evalExpression(data, expr.args?.[1]);
+      if (f === "has") {
+        return fieldArg.some((item) => item === search);
+      } else if (f === "hasEvery") {
+        invariant(Array.isArray(search), "hasEvery second argument must be an array");
+        return search.every((v) => fieldArg.some((item) => item === v));
+      } else {
+        invariant(Array.isArray(search), "hasSome second argument must be an array");
+        return search.some((v) => fieldArg.some((item) => item === v));
+      }
+    }
+    case "isEmpty": {
+      if (fieldArg === void 0 || fieldArg === null) {
+        return false;
+      }
+      invariant(Array.isArray(fieldArg), `"${f}" first argument must be an array field`);
+      return fieldArg.length === 0;
+    }
+    default:
+      throw new SchemaFactoryError(`Unsupported function "${f}"`);
+  }
+}
+__name(evalCall, "evalCall");
+function invariant(condition, message) {
+  if (!condition) {
+    throw new SchemaFactoryError(message ?? "Invariant failed");
+  }
+}
+__name(invariant, "invariant");
+
+// src/factory.ts
+function createSchemaFactory(schema) {
+  return new SchemaFactory(schema);
+}
+__name(createSchemaFactory, "createSchemaFactory");
+var SchemaFactory = class SchemaFactory2 {
+  static {
+    __name(this, "SchemaFactory");
+  }
+  schema;
+  constructor(_schema) {
+    this.schema = new SchemaAccessor(_schema);
+  }
+  makeModelSchema(model) {
+    const modelDef = this.schema.requireModel(model);
+    const fields = {};
+    for (const [fieldName, fieldDef] of Object.entries(modelDef.fields)) {
+      if (fieldDef.relation) {
+        const relatedModelName = fieldDef.type;
+        const lazySchema = z2.lazy(() => this.makeModelSchema(relatedModelName));
+        fields[fieldName] = this.applyDescription(this.applyCardinality(lazySchema, fieldDef).optional(), fieldDef.attributes);
+      } else {
+        fields[fieldName] = this.applyDescription(this.makeScalarFieldSchema(fieldDef), fieldDef.attributes);
+      }
+    }
+    const shape = z2.strictObject(fields);
+    return this.applyDescription(addCustomValidation(shape, modelDef.attributes), modelDef.attributes);
+  }
+  makeModelCreateSchema(model) {
+    const modelDef = this.schema.requireModel(model);
+    const fields = {};
+    for (const [fieldName, fieldDef] of Object.entries(modelDef.fields)) {
+      if (fieldDef.relation || fieldDef.computed || fieldDef.isDiscriminator) {
+        continue;
+      }
+      let fieldSchema = this.makeScalarFieldSchema(fieldDef);
+      if (fieldDef.optional || fieldDef.default !== void 0 || fieldDef.updatedAt) {
+        fieldSchema = fieldSchema.optional();
+      }
+      fields[fieldName] = this.applyDescription(fieldSchema, fieldDef.attributes);
+    }
+    const shape = z2.strictObject(fields);
+    return this.applyDescription(addCustomValidation(shape, modelDef.attributes), modelDef.attributes);
+  }
+  makeModelUpdateSchema(model) {
+    const modelDef = this.schema.requireModel(model);
+    const fields = {};
+    for (const [fieldName, fieldDef] of Object.entries(modelDef.fields)) {
+      if (fieldDef.relation || fieldDef.computed || fieldDef.isDiscriminator) {
+        continue;
+      }
+      let fieldSchema = this.makeScalarFieldSchema(fieldDef);
+      fieldSchema = fieldSchema.optional();
+      fields[fieldName] = this.applyDescription(fieldSchema, fieldDef.attributes);
+    }
+    const shape = z2.strictObject(fields);
+    return this.applyDescription(addCustomValidation(shape, modelDef.attributes), modelDef.attributes);
+  }
+  makeScalarFieldSchema(fieldDef) {
+    const { type, attributes } = fieldDef;
+    const enumDef = this.schema.getEnum(type);
+    if (enumDef) {
+      return this.applyCardinality(this.makeEnumSchema(type), fieldDef);
+    }
+    const typedefDef = this.schema.getTypeDef(type);
+    if (typedefDef) {
+      return this.applyCardinality(this.makeTypeSchema(type), fieldDef);
+    }
+    let base;
+    switch (type) {
+      case "String":
+        base = addStringValidation(z2.string(), attributes);
+        break;
+      case "Int":
+        base = addNumberValidation(z2.number().int(), attributes);
+        break;
+      case "Float":
+        base = addNumberValidation(z2.number(), attributes);
+        break;
+      case "Boolean":
+        base = z2.boolean();
+        break;
+      case "BigInt":
+        base = addBigIntValidation(z2.bigint(), attributes);
+        break;
+      case "Decimal":
+        base = z2.union([
+          addNumberValidation(z2.number(), attributes),
+          addDecimalValidation(z2.string(), attributes, true),
+          addDecimalValidation(z2.instanceof(Decimal2), attributes, true)
+        ]);
+        break;
+      case "DateTime":
+        base = z2.union([
+          z2.date(),
+          z2.iso.datetime()
+        ]);
+        break;
+      case "Bytes":
+        base = z2.instanceof(Uint8Array);
+        break;
+      case "Json":
+        base = this.makeJsonSchema();
+        break;
+      case "Unsupported":
+        base = z2.unknown();
+        break;
+      default: {
+        const _exhaustive = type;
+        throw new SchemaFactoryError(`Unsupported field type: ${_exhaustive}`);
+      }
+    }
+    return this.applyCardinality(base, fieldDef);
+  }
+  makeJsonSchema() {
+    return z2.union([
+      z2.string(),
+      z2.number(),
+      z2.boolean(),
+      z2.null(),
+      z2.array(z2.lazy(() => this.makeJsonSchema())),
+      z2.object({}).catchall(z2.lazy(() => this.makeJsonSchema()))
+    ]);
+  }
+  applyCardinality(schema, fieldDef) {
+    let result = schema;
+    if (fieldDef.array) {
+      result = result.array();
+    }
+    if (fieldDef.optional) {
+      result = result.nullable().optional();
+    }
+    return result;
+  }
+  makeTypeSchema(type) {
+    const typeDef = this.schema.requireTypeDef(type);
+    const fields = {};
+    for (const [fieldName, fieldDef] of Object.entries(typeDef.fields)) {
+      fields[fieldName] = this.applyDescription(this.makeScalarFieldSchema(fieldDef), fieldDef.attributes);
+    }
+    const shape = z2.strictObject(fields);
+    return this.applyDescription(addCustomValidation(shape, typeDef.attributes), typeDef.attributes);
+  }
+  makeEnumSchema(_enum) {
+    const enumDef = this.schema.requireEnum(_enum);
+    const schema = z2.enum(Object.keys(enumDef.values));
+    return this.applyDescription(schema, enumDef.attributes);
+  }
+  getMetaDescription(attributes) {
+    if (!attributes) return void 0;
+    for (const attr of attributes) {
+      if (attr.name !== "@meta" && attr.name !== "@@meta") continue;
+      const nameExpr = attr.args?.[0]?.value;
+      if (!nameExpr || ExpressionUtils2.getLiteralValue(nameExpr) !== "description") continue;
+      const valueExpr = attr.args?.[1]?.value;
+      if (valueExpr) {
+        return ExpressionUtils2.getLiteralValue(valueExpr);
+      }
+    }
+    return void 0;
+  }
+  applyDescription(schema, attributes) {
+    const description = this.getMetaDescription(attributes);
+    if (description) {
+      return schema.meta({
+        description
+      });
+    }
+    return schema;
+  }
+};
 export {
-  makeSelectSchema
+  utils_exports as ZodUtils,
+  createSchemaFactory
 };
 //# sourceMappingURL=index.js.map