@lunora/values 0.0.0 → 1.0.0-alpha.1

package/dist/packem_shared/isOrWrapsFromValidator-DJMAE0l9.mjs

@@ -0,0 +1,412 @@
+import { ValidationError, formatPath, describeValue } from './ValidationError-DWWcFe37.mjs';
+
+function fail(context, expected, received) {
+  const path = [...context.path];
+  const receivedDescription = describeValue(received);
+  throw new ValidationError(`Expected ${expected} at ${formatPath(path)}, received ${receivedDescription}`, {
+    expected,
+    path,
+    received: receivedDescription
+  });
+}
+const mergeConstraints = (meta, fragment) => {
+  if (fragment === void 0) {
+    return meta;
+  }
+  const previous = meta?.constraints;
+  return { ...meta, constraints: { ...previous, ...fragment } };
+};
+const createValidator = (kind, parser, meta) => {
+  const column = meta?.column ?? { notNull: true };
+  const validator = {
+    __type: void 0,
+    // The Standard Schema v1 surface (https://standardschema.dev). `validate`
+    // delegates to `safeParse`: on success it returns `{ value }`, on a
+    // ValidationError it maps to `{ issues: [...] }`. Lunora paths are already
+    // `(string | number)[]`, a subset of Standard Schema's
+    // `ReadonlyArray<PropertyKey | PathSegment>`, so they pass through
+    // verbatim — no per-segment wrapping needed (same as Zod/Valibot, which
+    // also emit bare keys). Synchronous validate is permitted by the spec.
+    "~standard": {
+      /** @returns A Standard Schema result object — either `{ value }` on success or `{ issues }` on failure. */
+      validate(value) {
+        const result = validator.safeParse(value);
+        if (result.ok) {
+          return { value: result.value };
+        }
+        return { issues: [{ message: result.error.message, path: result.error.path }] };
+      },
+      vendor: "lunora",
+      version: 1
+    },
+    _meta: { ...meta, column },
+    _parse(value, context) {
+      return parser(value, context);
+    },
+    kind,
+    parse(value) {
+      return parser(value, { path: [] });
+    },
+    /** @returns `{ ok: true, value }` on success or `{ ok: false, error }` on a validation failure. */
+    safeParse(value) {
+      try {
+        return { ok: true, value: parser(value, { path: [] }) };
+      } catch (error) {
+        if (error instanceof ValidationError) {
+          return { error, ok: false };
+        }
+        throw error;
+      }
+    }
+  };
+  const rebuild = (patch) => createValidator(kind, parser, { ...meta, column: { ...column, ...patch } });
+  validator.default = (value) => rebuild({ defaultValue: value });
+  validator.defaultNow = () => rebuild({ defaultFn: () => Date.now() });
+  validator.unique = () => rebuild({ unique: true });
+  validator.$defaultFn = (function_) => rebuild({ defaultFn: function_ });
+  validator.$onUpdateFn = (function_) => rebuild({ onUpdateFn: function_ });
+  validator.serverDefault = (function_) => rebuild({ serverDefault: function_ });
+  validator.$type = (() => rebuild({}));
+  validator.nullable = () => {
+    const nullableParser = (value, context) => value === null ? null : parser(value, context);
+    return createValidator(kind, nullableParser, { ...meta, column: { ...column, notNull: false } });
+  };
+  validator.check = (predicate, options) => {
+    const message = typeof options === "string" ? options : options?.message;
+    const fragment = typeof options === "string" ? void 0 : options?.schema;
+    const refinedParser = (value, context) => {
+      const parsed = parser(value, context);
+      if (!predicate(parsed)) {
+        fail(context, message ?? "value matching refinement", parsed);
+      }
+      return parsed;
+    };
+    return createValidator(kind, refinedParser, mergeConstraints(meta, fragment));
+  };
+  validator.meta = (options) => {
+    const fragment = options.description === void 0 ? options.schema : { description: options.description, ...options.schema };
+    return createValidator(kind, parser, mergeConstraints(meta, fragment));
+  };
+  return validator;
+};
+const toInternal = (validator) => validator;
+const asColumn = (validator) => validator;
+const string = () => asColumn(
+  createValidator("string", (value, context) => {
+    if (typeof value !== "string") {
+      fail(context, "string", value);
+    }
+    return value;
+  })
+);
+const number = () => asColumn(
+  createValidator("number", (value, context) => {
+    if (typeof value !== "number" || !Number.isFinite(value)) {
+      fail(context, "number", value);
+    }
+    return value;
+  })
+);
+const parseEpochMillis = (value, context) => {
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    fail(context, "number", value);
+  }
+  return value;
+};
+const timestamp = () => createValidator("timestamp", parseEpochMillis);
+const date = () => createValidator("date", parseEpochMillis);
+const boolean = () => asColumn(
+  createValidator("boolean", (value, context) => {
+    if (typeof value !== "boolean") {
+      fail(context, "boolean", value);
+    }
+    return value;
+  })
+);
+const bigintValidator = () => asColumn(
+  createValidator("bigint", (value, context) => {
+    if (typeof value !== "bigint") {
+      fail(context, "bigint", value);
+    }
+    return value;
+  })
+);
+const nullValidator = () => asColumn(
+  createValidator("null", (value, context) => {
+    if (value !== null) {
+      fail(context, "null", value);
+    }
+    return value;
+  })
+);
+const bytes = () => asColumn(
+  createValidator("bytes", (value, context) => {
+    if (!(value instanceof ArrayBuffer)) {
+      fail(context, "ArrayBuffer", value);
+    }
+    return value;
+  })
+);
+const id = (tableName) => asColumn(
+  createValidator(
+    "id",
+    (value, context) => {
+      if (typeof value !== "string") {
+        fail(context, `Id<"${tableName}">`, value);
+      }
+      return value;
+    },
+    { tableName }
+  )
+);
+const storage = (bucket) => asColumn(
+  createValidator(
+    "storage",
+    (value, context) => {
+      if (typeof value !== "string") {
+        fail(context, "storage object key (string)", value);
+      }
+      return value;
+    },
+    bucket === void 0 ? void 0 : { bucket }
+  )
+);
+const literal = (literalValue) => asColumn(
+  createValidator(
+    "literal",
+    (value, context) => {
+      if (value !== literalValue) {
+        fail(context, `literal(${String(literalValue)})`, value);
+      }
+      return value;
+    },
+    { value: literalValue }
+  )
+);
+const array = (inner) => {
+  const innerInternal = toInternal(inner);
+  return asColumn(
+    createValidator(
+      "array",
+      (value, context) => {
+        if (!Array.isArray(value)) {
+          fail(context, "array", value);
+        }
+        const { length } = value;
+        const out = Array.from({ length });
+        const { path } = context;
+        for (let index = 0; index < length; index += 1) {
+          path.push(index);
+          out[index] = innerInternal._parse(value[index], context);
+          path.pop();
+        }
+        return out;
+      },
+      { inner }
+    )
+  );
+};
+const objectValidator = (shape) => {
+  const entries = Object.keys(shape).map((key) => {
+    const child = toInternal(shape[key]);
+    return { child, isOptional: child.kind === "optional", key };
+  });
+  return asColumn(
+    createValidator(
+      "object",
+      (value, context) => {
+        if (typeof value !== "object" || value === null || Array.isArray(value)) {
+          fail(context, "object", value);
+        }
+        const input = value;
+        const out = {};
+        const { path } = context;
+        for (const { child, isOptional, key } of entries) {
+          const fieldValue = input[key];
+          if (fieldValue === void 0 && isOptional) {
+            continue;
+          }
+          path.push(key);
+          out[key] = child._parse(fieldValue, context);
+          path.pop();
+        }
+        return out;
+      },
+      { shape }
+    )
+  );
+};
+const record = (keyValidator, valueValidator) => {
+  const keyInternal = toInternal(keyValidator);
+  const valueInternal = toInternal(valueValidator);
+  return asColumn(
+    createValidator(
+      "record",
+      (value, context) => {
+        if (typeof value !== "object" || value === null || Array.isArray(value)) {
+          fail(context, "record", value);
+        }
+        const input = value;
+        const out = /* @__PURE__ */ Object.create(null);
+        const { path } = context;
+        for (const key of Object.keys(input)) {
+          path.push(key);
+          const parsedKey = keyInternal._parse(key, context);
+          const parsedValue = valueInternal._parse(input[key], context);
+          path.pop();
+          out[parsedKey] = parsedValue;
+        }
+        return out;
+      },
+      { keyValidator, valueValidator }
+    )
+  );
+};
+const union = (...members) => {
+  if (members.length === 0) {
+    throw new Error("v.union requires at least one member");
+  }
+  const memberInternals = members.map((member) => toInternal(member));
+  return asColumn(
+    createValidator(
+      "union",
+      (value, context) => {
+        let deepestError;
+        const { path } = context;
+        const baseDepth = path.length;
+        for (const member of memberInternals) {
+          try {
+            return member._parse(value, context);
+          } catch (error) {
+            if (!(error instanceof ValidationError)) {
+              throw error;
+            }
+            path.length = baseDepth;
+            if (deepestError === void 0 || error.path.length > deepestError.path.length) {
+              deepestError = error;
+            }
+          }
+        }
+        if (memberInternals.length === 1 && deepestError !== void 0) {
+          throw deepestError;
+        }
+        const detail = deepestError === void 0 ? "" : ` (closest: expected ${deepestError.expected} at ${formatPath(deepestError.path)})`;
+        return fail(context, `union of ${String(members.length)} member(s)${detail}`, value);
+      },
+      { members }
+    )
+  );
+};
+const optional = (inner) => {
+  const innerInternal = toInternal(inner);
+  return asColumn(
+    createValidator(
+      "optional",
+      (value, context) => value === void 0 ? void 0 : innerInternal._parse(value, context),
+      { inner }
+    )
+  );
+};
+const any = () => asColumn(createValidator("any", (value) => value));
+const standardIssuePath = (path) => {
+  const issuePath = [];
+  if (!path) {
+    return issuePath;
+  }
+  for (const segment of path) {
+    const key = typeof segment === "object" && segment !== null && "key" in segment ? segment.key : segment;
+    if (typeof key === "string" || typeof key === "number") {
+      issuePath.push(key);
+    }
+  }
+  return issuePath;
+};
+const from = (schema) => {
+  const props = schema["~standard"];
+  if (props?.version !== 1 || typeof props.validate !== "function") {
+    throw new Error('@lunora/values: v.from() expects a Standard Schema v1 object (missing or invalid "~standard")');
+  }
+  const validate = props.validate;
+  return asColumn(
+    createValidator("from", (value, context) => {
+      const result = validate(value);
+      if (result instanceof Promise || typeof result?.then === "function") {
+        throw new ValidationError("v.from(): async Standard Schema validators are not supported in args", {
+          expected: "sync Standard Schema result",
+          path: [...context.path],
+          received: "Promise"
+        });
+      }
+      const looseResult = result;
+      if (looseResult === null || typeof looseResult !== "object") {
+        throw new ValidationError("v.from(): Standard Schema validator returned a non-object result", {
+          expected: "Standard Schema result object",
+          path: [...context.path],
+          received: describeValue(looseResult)
+        });
+      }
+      const syncResult = result;
+      const syncResultObject = syncResult;
+      if ("issues" in syncResultObject && syncResult.issues !== void 0 && syncResult.issues.length > 0) {
+        const first = syncResult.issues[0];
+        const message = first?.message ?? "Standard Schema validation failed";
+        throw new ValidationError(message, {
+          expected: "valid value",
+          path: [...context.path, ...standardIssuePath(first?.path)],
+          received: describeValue(value)
+        });
+      }
+      return syncResult.value;
+    })
+  );
+};
+const isOrWrapsFromValidator = (validator) => {
+  if (validator.kind === "from") {
+    return true;
+  }
+  const meta = validator._meta;
+  if (!meta) {
+    return false;
+  }
+  const children = [meta.inner, meta.keyValidator, meta.valueValidator];
+  if (Array.isArray(meta.members)) {
+    children.push(...meta.members);
+  }
+  if (meta.shape !== null && typeof meta.shape === "object") {
+    children.push(...Object.values(meta.shape));
+  }
+  for (const child of children) {
+    if (child !== null && typeof child === "object" && "kind" in child && isOrWrapsFromValidator(child)) {
+      return true;
+    }
+  }
+  return false;
+};
+const optionalInner = (validator) => {
+  if (validator.kind !== "optional") {
+    return void 0;
+  }
+  return validator._meta?.inner;
+};
+const v = {
+  any,
+  array,
+  bigint: bigintValidator,
+  boolean,
+  bytes,
+  date,
+  from,
+  id,
+  literal,
+  null: nullValidator,
+  number,
+  object: objectValidator,
+  optional,
+  record,
+  storage,
+  string,
+  timestamp,
+  union
+};
+
+export { isOrWrapsFromValidator, optionalInner, v };

package/dist/packem_shared/jsonSchemaFromNode-weszUOQG.mjs

@@ -0,0 +1,82 @@
+const jsonSchemaFromNode = (node, reader) => {
+  const base = (() => {
+    switch (reader.kind(node)) {
+      case "any": {
+        return {};
+      }
+      case "array": {
+        const inner = reader.inner(node);
+        return { items: inner === void 0 ? {} : jsonSchemaFromNode(inner, reader), type: "array" };
+      }
+      case "bigint": {
+        return { format: "int64", type: "integer" };
+      }
+      case "boolean": {
+        return { type: "boolean" };
+      }
+      case "bytes": {
+        return { contentEncoding: "base64", description: "binary (ArrayBuffer)", type: "string" };
+      }
+      case "date": {
+        return { description: "epoch milliseconds (date)", type: "integer" };
+      }
+      case "id": {
+        return { description: `Id<"${String(reader.tableName(node))}">`, type: "string", "x-lunora-table": reader.tableName(node) };
+      }
+      case "literal": {
+        return reader.literalSchema(node);
+      }
+      case "null": {
+        return { type: "null" };
+      }
+      case "number": {
+        return { type: "number" };
+      }
+      case "object": {
+        return objectSchemaFromNodes(reader.shape(node), reader);
+      }
+      case "optional": {
+        const inner = reader.inner(node);
+        return inner === void 0 ? {} : jsonSchemaFromNode(inner, reader);
+      }
+      case "record": {
+        const value = reader.valueChild(node);
+        return { additionalProperties: value === void 0 ? {} : jsonSchemaFromNode(value, reader), type: "object" };
+      }
+      case "storage": {
+        return { description: "storage object key", type: "string", "x-lunora-storage": true };
+      }
+      case "string": {
+        return { type: "string" };
+      }
+      case "timestamp": {
+        return { description: "epoch milliseconds (timestamp)", type: "integer" };
+      }
+      case "union": {
+        return { anyOf: reader.members(node).map((member) => jsonSchemaFromNode(member, reader)) };
+      }
+      default: {
+        return {};
+      }
+    }
+  })();
+  const constraints = reader.constraints(node);
+  const withConstraints = constraints === void 0 ? base : { ...base, ...constraints };
+  if (reader.isNullable(node)) {
+    return { anyOf: [withConstraints, { type: "null" }] };
+  }
+  return withConstraints;
+};
+const objectSchemaFromNodes = (shape, reader) => {
+  const properties = {};
+  const required = [];
+  for (const [key, child] of Object.entries(shape)) {
+    properties[key] = jsonSchemaFromNode(child, reader);
+    if (reader.kind(child) !== "optional") {
+      required.push(key);
+    }
+  }
+  return { additionalProperties: false, properties, required, type: "object" };
+};
+
+export { jsonSchemaFromNode, objectSchemaFromNodes };

package/dist/packem_shared/parseValidatorMap-CCjevE5Z.mjs

@@ -0,0 +1,30 @@
+import { ValidationError } from './ValidationError-DWWcFe37.mjs';
+
+const parseValidatorMap = (validators, source, label) => {
+  const out = {};
+  for (const key of Object.keys(validators)) {
+    const validator = validators[key];
+    if (!validator) {
+      continue;
+    }
+    const candidate = source[key];
+    if (candidate === void 0 && validator.kind === "optional") {
+      continue;
+    }
+    try {
+      out[key] = validator.parse(candidate);
+    } catch (error) {
+      if (error instanceof ValidationError) {
+        throw new ValidationError(`${label}.${key}: ${error.message}`, {
+          expected: error.expected,
+          path: [key, ...error.path],
+          received: error.received
+        });
+      }
+      throw error;
+    }
+  }
+  return out;
+};
+
+export { parseValidatorMap };

package/package.json

@@ -1,31 +1,51 @@
 {
   "name": "@lunora/values",
-  "version": "0.0.0",
+  "version": "1.0.0-alpha.1",
   "description": "Validators for Lunora: the v.* validator suite with end-to-end return-type inference",
-  "license": "FSL-1.1-Apache-2.0",
+  "keywords": [
+    "cloudflare",
+    "durable-objects",
+    "lunora",
+    "schema",
+    "standard-schema",
+    "type-inference",
+    "validation",
+    "workers"
+  ],
   "homepage": "https://lunora.sh",
+  "bugs": "https://github.com/anolilab/lunora/issues",
+  "license": "FSL-1.1-Apache-2.0",
+  "author": {
+    "name": "Daniel Bannert",
+    "email": "d.bannert@anolilab.de"
+  },
   "repository": {
     "type": "git",
     "url": "git+https://github.com/anolilab/lunora.git",
     "directory": "packages/values"
   },
-  "bugs": {
-    "url": "https://github.com/anolilab/lunora/issues"
-  },
-  "keywords": [
-    "lunora",
-    "cloudflare",
-    "workers",
-    "durable-objects",
-    "validation",
-    "schema",
-    "type-inference",
-    "standard-schema"
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE.md",
+    "__assets__"
   ],
+  "type": "module",
+  "sideEffects": false,
+  "main": "./dist/index.mjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs"
+    },
+    "./package.json": "./package.json"
+  },
   "publishConfig": {
     "access": "public"
   },
-  "files": [
-    "README.md"
-  ]
+  "engines": {
+    "node": "^22.15.0 || >=24.11.0"
+  }
 }