@stndrds/schema 1.0.0-alpha.199 → 1.0.0-alpha.201

package/dist/chunk-AAXJJNY6.mjs

@@ -0,0 +1,509 @@
+import { z } from 'zod';
+
+// src/validation/config/schemas.ts
+
+// src/computed/parser.ts
+var ComputedFormulaParseError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ComputedFormulaParseError";
+  }
+};
+function parseComputedFormula(expression) {
+  const parser = new Parser(tokenize(expression));
+  const ast = parser.parseExpression();
+  parser.expectEnd();
+  return ast;
+}
+function tokenize(expression) {
+  const tokens = [];
+  let index = 0;
+  while (index < expression.length) {
+    const char = expression[index];
+    if (char === " " || char === "	" || char === "\n" || char === "\r") {
+      index += 1;
+      continue;
+    }
+    if (char === '"' || char === "'") {
+      const result = scanString(expression, index, char);
+      tokens.push({ kind: "string", value: result.value, position: index });
+      index = result.nextIndex;
+      continue;
+    }
+    if (isDigit(char)) {
+      const result = scanNumber(expression, index);
+      tokens.push({ kind: "number", value: result.value, position: index });
+      index = result.nextIndex;
+      continue;
+    }
+    if (isIdentifierStart(char)) {
+      const result = scanIdentifier(expression, index);
+      const canonical = result.value.toLowerCase();
+      if (canonical === "true") {
+        tokens.push({ kind: "boolean", value: true, position: index });
+      } else if (canonical === "false") {
+        tokens.push({ kind: "boolean", value: false, position: index });
+      } else if (canonical === "null") {
+        tokens.push({ kind: "null", position: index });
+      } else {
+        tokens.push({ kind: "identifier", value: result.value, position: index });
+      }
+      index = result.nextIndex;
+      continue;
+    }
+    const twoChar = expression.slice(index, index + 2);
+    if (twoChar === ">=" || twoChar === "<=" || twoChar === "==" || twoChar === "!=") {
+      tokens.push({ kind: "operator", value: twoChar, position: index });
+      index += 2;
+      continue;
+    }
+    if (char === ">" || char === "<" || char === "+" || char === "-" || char === "*" || char === "/") {
+      tokens.push({ kind: "operator", value: char, position: index });
+      index += 1;
+      continue;
+    }
+    if (char === "(" || char === ")" || char === "," || char === ".") {
+      tokens.push({ kind: "punctuation", value: char, position: index });
+      index += 1;
+      continue;
+    }
+    throw new ComputedFormulaParseError(`Unexpected character "${char}" at position ${index}`);
+  }
+  return tokens;
+}
+function scanString(expression, startIndex, delimiter = '"') {
+  let value = "";
+  let index = startIndex + 1;
+  while (index < expression.length) {
+    const char = expression[index];
+    if (char === delimiter) {
+      return { value, nextIndex: index + 1 };
+    }
+    if (char === "\\") {
+      const escaped = expression[index + 1];
+      if (escaped === void 0) {
+        throw new ComputedFormulaParseError(`Unterminated string literal at position ${index}`);
+      }
+      value += decodeEscape(escaped, index);
+      index += 2;
+      continue;
+    }
+    value += char;
+    index += 1;
+  }
+  throw new ComputedFormulaParseError(`Unterminated string literal at position ${startIndex}`);
+}
+function decodeEscape(char, position) {
+  switch (char) {
+    case '"':
+    case "\\":
+      return char;
+    case "n":
+      return "\n";
+    case "r":
+      return "\r";
+    case "t":
+      return "	";
+    default:
+      throw new ComputedFormulaParseError(
+        `Unknown escape sequence "\\${char}" at position ${position}`
+      );
+  }
+}
+function scanNumber(expression, startIndex) {
+  let index = startIndex;
+  while (index < expression.length && isDigit(expression[index])) {
+    index += 1;
+  }
+  if (expression[index] === ".") {
+    const decimalStart = index;
+    index += 1;
+    if (!isDigit(expression[index])) {
+      throw new ComputedFormulaParseError(`Invalid number literal at position ${decimalStart}`);
+    }
+    while (index < expression.length && isDigit(expression[index])) {
+      index += 1;
+    }
+  }
+  const raw = expression.slice(startIndex, index);
+  const value = Number(raw);
+  if (!Number.isFinite(value)) {
+    throw new ComputedFormulaParseError(`Invalid number literal "${raw}"`);
+  }
+  return { value, nextIndex: index };
+}
+function scanIdentifier(expression, startIndex) {
+  let index = startIndex + 1;
+  while (index < expression.length && isIdentifierPart(expression[index])) {
+    index += 1;
+  }
+  return { value: expression.slice(startIndex, index), nextIndex: index };
+}
+function isDigit(char) {
+  return char !== void 0 && char >= "0" && char <= "9";
+}
+function isIdentifierStart(char) {
+  return char !== void 0 && /[A-Za-z_]/.test(char);
+}
+function isIdentifierPart(char) {
+  return char !== void 0 && /[A-Za-z0-9_]/.test(char);
+}
+var Parser = class {
+  constructor(tokens) {
+    this.tokens = tokens;
+    this.position = 0;
+  }
+  parseExpression() {
+    return this.parseBinaryExpression(0);
+  }
+  expectEnd() {
+    const token = this.peek();
+    if (token !== void 0) {
+      throw new ComputedFormulaParseError(
+        `Unexpected token ${describeToken(token)} at position ${token.position}`
+      );
+    }
+  }
+  parseBinaryExpression(minPrecedence) {
+    let left = this.parsePrimary();
+    while (true) {
+      const token = this.peek();
+      if (token?.kind !== "operator") {
+        return left;
+      }
+      const precedence = getOperatorPrecedence(token.value);
+      if (precedence < minPrecedence) {
+        return left;
+      }
+      const operator = token.value;
+      this.consume();
+      const right = this.parseBinaryExpression(precedence + 1);
+      left = { kind: "binary", operator, left, right };
+    }
+  }
+  parsePrimary() {
+    const token = this.consume();
+    if (token === void 0) {
+      throw new ComputedFormulaParseError("Unexpected end of expression");
+    }
+    switch (token.kind) {
+      case "string":
+      case "number":
+      case "boolean":
+        return { kind: "literal", value: token.value };
+      case "null":
+        return { kind: "literal", value: null };
+      case "identifier":
+        return this.parseIdentifier(token.value);
+      case "punctuation":
+        if (token.value === "(") {
+          const expression = this.parseExpression();
+          this.expectPunctuation(")");
+          return expression;
+        }
+        break;
+      case "operator":
+        if (token.value === "-") {
+          const next = this.consume();
+          if (next?.kind === "number") {
+            return { kind: "literal", value: -next.value };
+          }
+        }
+        break;
+    }
+    throw new ComputedFormulaParseError(
+      `Expected literal, path, call, or parenthesized expression at position ${token.position}`
+    );
+  }
+  parseIdentifier(identifier) {
+    if (this.matchPunctuation("(")) {
+      const args = [];
+      if (!this.matchPunctuation(")")) {
+        do {
+          args.push(this.parseExpression());
+        } while (this.matchPunctuation(","));
+        this.expectPunctuation(")");
+      }
+      return { kind: "call", functionName: identifier.toLowerCase(), args };
+    }
+    const parts = [identifier];
+    while (this.matchPunctuation(".")) {
+      const next = this.consume();
+      if (next?.kind !== "identifier") {
+        const position = next?.position ?? this.previousPosition();
+        throw new ComputedFormulaParseError(
+          `Expected attribute name after path separator at position ${position}`
+        );
+      }
+      parts.push(next.value);
+    }
+    return { kind: "path", parts };
+  }
+  expectPunctuation(value) {
+    if (!this.matchPunctuation(value)) {
+      const token = this.peek();
+      const position = token?.position ?? this.previousPosition();
+      throw new ComputedFormulaParseError(`Expected "${value}" at position ${position}`);
+    }
+  }
+  matchPunctuation(value) {
+    const token = this.peek();
+    if (token?.kind === "punctuation" && token.value === value) {
+      this.consume();
+      return true;
+    }
+    return false;
+  }
+  peek() {
+    return this.tokens[this.position];
+  }
+  consume() {
+    const token = this.tokens[this.position];
+    this.position += 1;
+    return token;
+  }
+  previousPosition() {
+    const previous = this.tokens[this.position - 1];
+    return previous?.position ?? 0;
+  }
+};
+function describeToken(token) {
+  switch (token.kind) {
+    case "identifier":
+    case "number":
+    case "string":
+    case "boolean":
+    case "operator":
+    case "punctuation":
+      return `"${String(token.value)}"`;
+    case "null":
+      return '"null"';
+    default: {
+      const exhaustive = token;
+      return exhaustive;
+    }
+  }
+}
+function getOperatorPrecedence(operator) {
+  switch (operator) {
+    case "*":
+    case "/":
+      return 3;
+    case "+":
+    case "-":
+      return 2;
+    case ">":
+    case "<":
+    case ">=":
+    case "<=":
+    case "==":
+    case "!=":
+      return 1;
+    default: {
+      const exhaustive = operator;
+      return exhaustive;
+    }
+  }
+}
+
+// src/validation/config/schemas.ts
+var baseConfigSchema = z.object({
+  placeholder: z.string().optional(),
+  description: z.string().optional(),
+  defaultValue: z.unknown().optional(),
+  icon: z.string().optional(),
+  order: z.number().int().optional(),
+  hidden: z.boolean().optional(),
+  archived: z.boolean().optional(),
+  deprecated: z.boolean().optional(),
+  metadata: z.record(z.string(), z.unknown()).optional()
+});
+var optionSchema = z.object({
+  value: z.string().min(1),
+  label: z.string().min(1),
+  color: z.string().optional(),
+  description: z.string().optional(),
+  group: z.enum(["idle", "in_progress", "finished"]).optional(),
+  inverse: z.string().optional(),
+  archived: z.boolean().optional()
+}).strict();
+var optionsArraySchema = z.array(optionSchema).min(1).refine(
+  (options) => {
+    const values = options.map((o) => o.value);
+    return new Set(values).size === values.length;
+  },
+  { message: "Duplicate option values are not allowed" }
+);
+var relationTargetSchema = z.object({
+  object: z.string().min(1),
+  displayTemplate: z.string().optional(),
+  filter: z.record(z.string(), z.unknown()).optional()
+});
+var bilateralConfigSchema = z.object({
+  object: z.string().min(1),
+  attribute: z.string().min(1),
+  cardinality: z.enum(["one", "many"]).optional(),
+  storageOwner: z.boolean().optional()
+});
+var computedOptionsSourceSchema = z.object({
+  objectName: z.string().min(1),
+  attributeName: z.string().min(1),
+  attributeId: z.string().optional()
+});
+var textConfigSchema = baseConfigSchema.extend({
+  multiline: z.boolean().optional(),
+  minLength: z.number().int().min(0).optional(),
+  maxLength: z.number().int().min(1).optional(),
+  pattern: z.string().optional(),
+  format: z.enum(["email", "url", "slug"]).optional()
+});
+var richtextConfigSchema = baseConfigSchema;
+var numberConfigSchema = baseConfigSchema.extend({
+  renderAs: z.enum(["number", "rating"]).optional(),
+  min: z.number().optional(),
+  max: z.number().optional(),
+  unit: z.enum(["integer", "decimal", "percentage"]).optional(),
+  decimals: z.number().int().min(0).max(10).optional()
+});
+var checkboxConfigSchema = baseConfigSchema;
+var dateConfigSchema = baseConfigSchema.extend({
+  dateFormat: z.enum(["short", "long", "full", "relative"]).optional(),
+  minDate: z.string().optional(),
+  maxDate: z.string().optional()
+});
+var phoneConfigSchema = baseConfigSchema.extend({
+  defaultCountryCode: z.string().length(3).optional()
+});
+var currencyConfigSchema = baseConfigSchema.extend({
+  defaultCurrency: z.string().length(3).optional(),
+  allowedCurrencies: z.array(z.string().length(3)).optional(),
+  allowNegative: z.boolean().optional()
+});
+var statusConfigSchema = baseConfigSchema.extend({
+  options: optionsArraySchema
+});
+var locationConfigSchema = baseConfigSchema.extend({
+  granularity: z.enum(["full", "address", "city", "state", "country", "coordinates"]).optional(),
+  defaultCountry: z.string().length(3).optional(),
+  allowedCountries: z.array(z.string().length(3)).optional()
+});
+var selectConfigSchema = baseConfigSchema.extend({
+  options: optionsArraySchema
+});
+var multiselectConfigSchema = baseConfigSchema.extend({
+  options: optionsArraySchema
+});
+var fileConfigSchema = baseConfigSchema.extend({
+  maxFiles: z.number().int().min(1).optional(),
+  maxSize: z.number().int().min(1).optional(),
+  allowedTypes: z.array(z.string()).optional(),
+  multiple: z.boolean().optional()
+});
+var userConfigSchema = baseConfigSchema.extend({
+  types: z.array(z.enum(["user", "agent"])).min(1).optional(),
+  multiple: z.boolean().optional()
+});
+var relationConfigSchema = baseConfigSchema.extend({
+  targets: z.array(relationTargetSchema).min(1),
+  cardinality: z.enum(["one", "many"]),
+  maxItems: z.number().int().min(1).optional(),
+  bilateral: bilateralConfigSchema.optional(),
+  /**
+   * PropertySchema declared via `.qualifyWith()`. Pass-through; structural
+   * validation happens at the builder level — see `propertySchemaPassthrough`
+   * comment further below for the rationale.
+   */
+  properties: z.object({ definitions: z.array(z.record(z.string(), z.unknown())) }).passthrough().optional()
+});
+var formulaConfigSchema = baseConfigSchema.extend({
+  // Validate the expression grammar up-front so an assignment-style "=" (or any
+  // other malformed syntax) is rejected at save time instead of crashing the
+  // computed write-path later. Type/attribute coherence is still checked
+  // downstream by compileComputedFormula, which needs the full schema.
+  expression: z.string().min(1).superRefine((value, ctx) => {
+    try {
+      parseComputedFormula(value);
+    } catch (error) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        message: error instanceof Error ? error.message : "Invalid formula expression"
+      });
+    }
+  }),
+  returnType: z.enum(["text", "number", "boolean", "date", "select", "multiselect"]),
+  decimals: z.number().int().min(0).max(10).optional(),
+  allowRelations: z.boolean().optional(),
+  optionsSource: computedOptionsSourceSchema.optional()
+});
+var rollupConfigSchema = baseConfigSchema.extend({
+  relationAttribute: z.string().min(1).optional(),
+  relationPath: z.string().optional(),
+  targetAttribute: z.string().min(1),
+  function: z.enum([
+    "sum",
+    "avg",
+    "earliest",
+    "latest",
+    "count",
+    "countValues",
+    "countUniqueValues",
+    "countEmpty",
+    "percentEmpty",
+    "percentNotEmpty",
+    "original"
+  ]),
+  decimals: z.number().int().min(0).max(10).optional(),
+  targetAttributeType: z.string().optional(),
+  targetAttributeOptions: z.array(optionSchema).optional(),
+  optionsSource: computedOptionsSourceSchema.optional()
+});
+var propertySchemaPassthrough = z.object({ definitions: z.array(z.record(z.string(), z.unknown())) }).passthrough();
+var documentSlotConfigPassthrough = z.object({
+  name: z.string(),
+  label: z.string().optional(),
+  description: z.string().optional(),
+  required: z.boolean().optional(),
+  acceptedMimeTypes: z.array(z.string()).optional(),
+  maxSizeBytes: z.number().optional()
+}).passthrough();
+var documentConfigSchema = baseConfigSchema.extend({
+  /**
+   * PropertySchema declared via `.qualifyWith()` on a document attribute.
+   * Drives hydration into `[{id, props}]` shape and write-time validation.
+   */
+  properties: propertySchemaPassthrough.optional(),
+  /** File slots declared via `.slots(...)`. */
+  slots: z.array(documentSlotConfigPassthrough).optional()
+});
+var attributeConfigSchemas = {
+  text: textConfigSchema,
+  richtext: richtextConfigSchema,
+  number: numberConfigSchema,
+  checkbox: checkboxConfigSchema,
+  date: dateConfigSchema,
+  phone: phoneConfigSchema,
+  currency: currencyConfigSchema,
+  status: statusConfigSchema,
+  location: locationConfigSchema,
+  select: selectConfigSchema,
+  multiselect: multiselectConfigSchema,
+  file: fileConfigSchema,
+  user: userConfigSchema,
+  relation: relationConfigSchema,
+  formula: formulaConfigSchema,
+  rollup: rollupConfigSchema,
+  document: documentConfigSchema
+};
+function getAttributeConfigSchema(type) {
+  const schema = attributeConfigSchemas[type];
+  if (!schema) {
+    throw new Error(`Unsupported attribute type: ${type}`);
+  }
+  return schema;
+}
+function parseAttributeConfig(type, config) {
+  const schema = getAttributeConfigSchema(type);
+  return schema.strip().parse(config);
+}
+
+export { ComputedFormulaParseError, attributeConfigSchemas, getAttributeConfigSchema, parseAttributeConfig, parseComputedFormula };