@adhd/apigen-base-logical 0.0.1

package/index.mjs

@@ -0,0 +1,751 @@
+const l = "$apigen";
+class g extends Error {
+  constructor(o) {
+    super(o), this.code = "E_DUP_CODEC", this.name = "CodecRegistryError";
+  }
+}
+function z(e) {
+  e == null || e.wellKnown;
+  const o = /* @__PURE__ */ new Map();
+  return {
+    register(n, r) {
+      if (o.has(n.id) && !(r != null && r.override))
+        throw new g(
+          `E_DUP_CODEC: a codec is already registered for id "${n.id}"`
+        );
+      o.set(n.id, n);
+    },
+    resolve(n) {
+      for (const r of o.values())
+        if (r.matches(n))
+          return r;
+    },
+    get(n) {
+      return o.get(n);
+    },
+    ids() {
+      return [...o.keys()];
+    },
+    freeze() {
+      const n = new Map(o), r = {
+        register() {
+          throw new g(
+            "E_DUP_CODEC: registry is frozen and cannot accept new codecs"
+          );
+        },
+        resolve(d) {
+          for (const a of n.values())
+            if (a.matches(d))
+              return a;
+        },
+        get(d) {
+          return n.get(d);
+        },
+        ids() {
+          return [...n.keys()];
+        },
+        freeze() {
+          return r;
+        }
+      };
+      return r;
+    }
+  };
+}
+const v = "x-apigen-logical", U = "x-apigen-codec", W = "x-apigen-ctor", K = "x-apigen-tojson", X = "0.1.0", j = [
+  "scalar",
+  "nominal",
+  "union",
+  "map",
+  "set"
+];
+function H(e) {
+  const o = e[v];
+  return typeof o == "string" && j.includes(o) ? o : void 0;
+}
+function Z(e) {
+  const o = e[U];
+  return typeof o == "string" ? o : void 0;
+}
+function h(e, o) {
+  return {
+    registry: e,
+    resolve: (t) => {
+      throw new Error(
+        `[apigen-logical] $ref "${t}" cannot be resolved in run-mode without a descriptor root. Supply a resolve() in the ctx override to handle $ref.`
+      );
+    },
+    seen: /* @__PURE__ */ new WeakSet(),
+    path: "",
+    mode: "strict",
+    ...o
+  };
+}
+function p(e, o, t) {
+  const n = t.registry.resolve(o);
+  if (n)
+    return n.encode(e, o, t);
+  const r = o.$ref;
+  if (typeof r == "string") {
+    const i = t.resolve(r);
+    return p(e, i, t);
+  }
+  const d = o.oneOf;
+  if (Array.isArray(d)) {
+    const i = S(e, d, o);
+    return p(e, i, t);
+  }
+  const a = o.type;
+  if (a === "array") {
+    if (!Array.isArray(e))
+      return D(e, o, t);
+    const i = o.items;
+    if (!i)
+      return e.map((c) => u(c));
+    const f = t.path;
+    return Array.isArray(i) ? e.map((c, _) => {
+      const s = i[_];
+      return s === void 0 ? u(c) : p(c, s, { ...t, path: `${f}/${_}` });
+    }) : e.map(
+      (c, _) => p(c, i, { ...t, path: `${f}/${_}` })
+    );
+  }
+  if (a === "object") {
+    if (e === null || typeof e != "object" || Array.isArray(e))
+      return D(e, o, t);
+    const i = o.properties;
+    if (!i)
+      return u(e);
+    const f = t.path, c = {};
+    for (const [_, s] of Object.entries(i)) {
+      const m = e[_];
+      m !== void 0 && (c[_] = p(m, s, {
+        ...t,
+        path: `${f}/${_}`
+      }));
+    }
+    return c;
+  }
+  return a == null ? D(e, o, t) : u(e);
+}
+function E(e, o, t) {
+  const n = t.registry.resolve(o);
+  if (n)
+    return n.decode(e, o, t);
+  const r = o.$ref;
+  if (typeof r == "string") {
+    const i = t.resolve(r);
+    return E(e, i, t);
+  }
+  const d = o.oneOf;
+  if (Array.isArray(d)) {
+    const i = S(e, d, o);
+    return E(e, i, t);
+  }
+  const a = o.type;
+  if (a === "array") {
+    if (!Array.isArray(e))
+      return e;
+    const i = o.items;
+    if (!i)
+      return e;
+    const f = t.path;
+    return Array.isArray(i) ? e.map((c, _) => {
+      const s = i[_];
+      return s === void 0 ? c : E(c, s, { ...t, path: `${f}/${_}` });
+    }) : e.map(
+      (c, _) => E(c, i, { ...t, path: `${f}/${_}` })
+    );
+  }
+  if (a === "object") {
+    if (e === null || typeof e != "object" || Array.isArray(e))
+      return e;
+    const i = o.properties;
+    if (!i)
+      return e;
+    const f = t.path, c = {};
+    for (const [_, s] of Object.entries(i)) {
+      const m = e[_];
+      m !== void 0 && (c[_] = E(m, s, {
+        ...t,
+        path: `${f}/${_}`
+      }));
+    }
+    return c;
+  }
+  return a == null ? M(e, t) : e;
+}
+function S(e, o, t, n) {
+  const r = t.discriminator;
+  if (r != null && r.propertyName) {
+    const d = e !== null && typeof e == "object" ? e[r.propertyName] : void 0;
+    if (typeof d == "string" && r.mapping) {
+      const a = r.mapping[d];
+      if (a) {
+        const i = o.find((f) => f.$ref === a);
+        if (i)
+          return i;
+      }
+    }
+  }
+  return o[0] ?? {};
+}
+function D(e, o, t) {
+  for (const n of t.registry.ids()) {
+    const r = t.registry.get(n);
+    if (r)
+      try {
+        const d = r.encode(e, r.schema, t);
+        return { [l]: n, v: d };
+      } catch {
+      }
+  }
+  return u(e);
+}
+function M(e, o) {
+  if (e !== null && typeof e == "object" && !Array.isArray(e) && l in e) {
+    const t = e, n = t[l], r = o.registry.get(n);
+    if (r)
+      return r.decode(t.v, r.schema, o);
+  }
+  return e;
+}
+function u(e) {
+  if (e === null || typeof e == "string" || typeof e == "number" || typeof e == "boolean")
+    return e;
+  if (Array.isArray(e))
+    return e.map(u);
+  if (typeof e == "object") {
+    const o = {};
+    for (const [t, n] of Object.entries(e))
+      n !== void 0 && (o[t] = u(n));
+    return o;
+  }
+  return null;
+}
+function q(e, o) {
+  const t = /* @__PURE__ */ new Set(), n = [e];
+  for (; n.length > 0; ) {
+    const r = n.pop();
+    if (!r || t.has(r))
+      continue;
+    t.add(r);
+    const d = r.$ref;
+    if (typeof d == "string") {
+      if (o) {
+        const s = o[d];
+        if (!s) {
+          const m = Object.keys(o).join(", ") || "(none)";
+          throw new Error(
+            `[apigen-logical] $ref "${d}" cannot be resolved. Available $defs: ${m}`
+          );
+        }
+        n.push(s);
+      }
+      continue;
+    }
+    const a = r.oneOf;
+    if (Array.isArray(a))
+      for (const s of a)
+        typeof s == "object" && s !== null && n.push(s);
+    const i = r.properties;
+    if (i)
+      for (const s of Object.values(i))
+        n.push(s);
+    const f = r.items;
+    if (Array.isArray(f))
+      for (const s of f)
+        typeof s == "object" && s !== null && n.push(s);
+    else
+      typeof f == "object" && f !== null && n.push(f);
+    const c = r.additionalProperties;
+    typeof c == "object" && c !== null && n.push(c);
+    const _ = r.propertyNames;
+    typeof _ == "object" && _ !== null && n.push(_);
+  }
+}
+function Q(e) {
+  return {
+    encode(o, t, n) {
+      const r = h(e, n);
+      return p(o, t, r);
+    },
+    decode(o, t, n) {
+      const r = h(e, n);
+      return E(o, t, r);
+    }
+  };
+}
+function x(e, o, t) {
+  try {
+    const n = t();
+    e.register(n);
+  } catch (n) {
+    if (P(n))
+      return;
+    throw n;
+  }
+}
+function P(e) {
+  return e === null || typeof e != "object" ? !1 : e.code === "MODULE_NOT_FOUND";
+}
+const b = {
+  id: "date-time",
+  kind: "scalar",
+  schema: { type: "string", format: "date-time" },
+  matches(e) {
+    return e.type === "string" && e.format === "date-time";
+  },
+  encode(e, o, t) {
+    return e.toISOString();
+  },
+  decode(e, o, t) {
+    if (typeof e != "string") {
+      if (t.mode === "strict")
+        throw new TypeError(
+          `[date-time] expected a string on the wire at "${t.path}", got ${typeof e}`
+        );
+      return new Date(String(e));
+    }
+    if (t.mode === "strict" && Number.isNaN(new Date(e).getTime()))
+      throw new TypeError(
+        `[date-time] invalid date-time string at "${t.path}": ${JSON.stringify(e)}`
+      );
+    return new Date(e);
+  }
+}, N = {
+  id: "int64",
+  kind: "scalar",
+  schema: { type: "string", format: "int64" },
+  matches(e) {
+    return e.type === "string" && e.format === "int64";
+  },
+  encode(e, o, t) {
+    return String(e);
+  },
+  decode(e, o, t) {
+    if (typeof e != "string") {
+      if (t.mode === "strict")
+        throw new TypeError(
+          `[int64] expected a string on the wire at "${t.path}", got ${typeof e}`
+        );
+      try {
+        return BigInt(Math.trunc(Number(e)));
+      } catch {
+        return BigInt(0);
+      }
+    }
+    if (t.mode === "strict")
+      return BigInt(e);
+    if (/^-?\d+$/.test(e))
+      try {
+        return BigInt(e);
+      } catch {
+        return BigInt(0);
+      }
+    return BigInt(0);
+  }
+};
+function ee(e) {
+  return e;
+}
+const F = {
+  id: "decimal",
+  kind: "scalar",
+  schema: { type: "string", format: "decimal" },
+  matches(e) {
+    return e.type === "string" && e.format === "decimal";
+  },
+  encode(e, o, t) {
+    return e;
+  },
+  decode(e, o, t) {
+    if (typeof e != "string") {
+      if (t.mode === "strict")
+        throw new TypeError(
+          `[decimal] expected a string on the wire at "${t.path}", got ${typeof e}`
+        );
+      return String(e);
+    }
+    if (t.mode === "strict" && !/^-?\d+(\.\d+)?$/.test(e))
+      throw new TypeError(
+        `[decimal] wire value "${e}" at "${t.path}" is not a valid decimal string`
+      );
+    return e;
+  }
+}, $ = {
+  id: "byte",
+  kind: "scalar",
+  schema: { type: "string", format: "byte" },
+  matches(e) {
+    return e.type === "string" && e.format === "byte";
+  },
+  encode(e, o, t) {
+    return Buffer.from(e).toString("base64");
+  },
+  decode(e, o, t) {
+    if (typeof e != "string") {
+      if (t.mode === "strict")
+        throw new TypeError(
+          `[byte] expected a base64 string on the wire at "${t.path}", got ${typeof e}`
+        );
+      return new Uint8Array(0);
+    }
+    if (t.mode === "strict" && !/^[A-Za-z0-9+/]*={0,2}$/.test(e))
+      throw new TypeError(
+        `[byte] wire value at "${t.path}" is not standard base64 (format:byte): "${e}"`
+      );
+    return new Uint8Array(Buffer.from(e, "base64"));
+  }
+}, R = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/, L = {
+  id: "uuid",
+  kind: "scalar",
+  schema: { type: "string", format: "uuid" },
+  matches(e) {
+    return e.type === "string" && e.format === "uuid";
+  },
+  encode(e, o, t) {
+    return e.toLowerCase();
+  },
+  decode(e, o, t) {
+    if (typeof e != "string") {
+      if (t.mode === "strict")
+        throw new TypeError(
+          `[uuid] expected a string on the wire at "${t.path}", got ${typeof e}`
+        );
+      return String(e).toLowerCase();
+    }
+    if (t.mode === "strict" && !R.test(e))
+      throw new TypeError(
+        `[uuid] wire value "${e}" at "${t.path}" is not a lowercase-hyphenated RFC 4122 UUID`
+      );
+    return e;
+  }
+}, O = "NaN", C = "Infinity", A = "-Infinity", G = /* @__PURE__ */ new Set([
+  O,
+  C,
+  A
+]), I = {
+  id: "number-special",
+  kind: "scalar",
+  schema: { type: "number" },
+  matches(e) {
+    return e.type === "number" && e.format === void 0;
+  },
+  encode(e, o, t) {
+    return Number.isNaN(e) ? O : e === 1 / 0 ? C : e === -1 / 0 ? A : e;
+  },
+  decode(e, o, t) {
+    if (typeof e == "number")
+      return e;
+    if (typeof e == "string") {
+      if (e === O)
+        return NaN;
+      if (e === C)
+        return 1 / 0;
+      if (e === A)
+        return -1 / 0;
+      const n = Number(e);
+      if (!Number.isNaN(n))
+        return n;
+    }
+    if (t.mode === "strict")
+      throw new TypeError(
+        `[number-special] unrecognized wire value at "${t.path}": ${JSON.stringify(e)}. Expected a number or one of ${[...G].join(", ")}.`
+      );
+    return NaN;
+  }
+}, w = [
+  b,
+  N,
+  F,
+  $,
+  L,
+  I
+];
+function te(e, o = {}) {
+  for (const t of w)
+    e.register(t, { override: o.override ?? !1 });
+}
+const T = [
+  b.id,
+  // 'date-time'
+  N.id,
+  // 'int64'
+  F.id,
+  // 'decimal'
+  $.id,
+  // 'byte'
+  L.id,
+  // 'uuid'
+  I.id
+  // 'number-special'
+], B = {
+  "date-time": {
+    encode: "$.toISOString()",
+    decode: "new Date($)",
+    mode: "native"
+  },
+  int64: {
+    encode: "String($)",
+    decode: "BigInt($)",
+    mode: "native"
+  },
+  decimal: {
+    // Default: branded string (zero-dep); opt-in to decimal.js for arithmetic.
+    // DESIGN §13.2 branded row / §18 resolved: mode:'branded', dep declared so
+    // generators can optionally inject it; consumers that never use Decimal
+    // never install it (§14.2).
+    encode: "$.toString()",
+    decode: "new Decimal($)",
+    imports: [],
+    dep: { name: "decimal.js", version: "^10" },
+    mode: "branded"
+  },
+  byte: {
+    encode: "Buffer.from($).toString('base64')",
+    decode: "new Uint8Array(Buffer.from($, 'base64'))",
+    mode: "native"
+  },
+  uuid: {
+    // UUID is a plain string in TS; encode normalises to lowercase.
+    encode: "$.toLowerCase()",
+    decode: "$",
+    mode: "native"
+  },
+  "number-special": {
+    // numToWire / wireToNum are stdlib helpers emitted inline by the engine.
+    encode: "numToWire($)",
+    decode: "wireToNum($)",
+    mode: "native"
+  }
+}, k = {
+  "date-time": {
+    encode: "$.isoformat()",
+    decode: "datetime.fromisoformat($)",
+    imports: ["from datetime import datetime"],
+    mode: "native"
+  },
+  int64: {
+    encode: "str($)",
+    decode: "int($)",
+    mode: "native"
+  },
+  decimal: {
+    encode: "str($)",
+    decode: "Decimal($)",
+    imports: ["from decimal import Decimal"],
+    mode: "native"
+  },
+  byte: {
+    encode: "b64encode($).decode()",
+    decode: "b64decode($)",
+    imports: ["from base64 import b64encode, b64decode"],
+    mode: "native"
+  },
+  uuid: {
+    encode: "str($)",
+    decode: "UUID($)",
+    imports: ["from uuid import UUID"],
+    mode: "native"
+  },
+  "number-special": {
+    // Python json.dumps maps float('nan')/float('inf') to null by default;
+    // the codec overrides with string sentinels (same as TS).
+    encode: "num_to_wire($)",
+    decode: "wire_to_num($)",
+    mode: "native"
+  }
+}, J = {
+  "date-time": {
+    // chrono::DateTime<Utc> serialises as RFC3339 via serde.
+    encode: "__SCAFFOLD_RUST_DATETIME_ENCODE__",
+    decode: "__SCAFFOLD_RUST_DATETIME_DECODE__",
+    imports: ["use chrono::{DateTime, Utc};"],
+    dep: { name: "chrono", version: "^0.4" },
+    mode: "lib"
+  },
+  int64: {
+    // serde_with DisplayFromStr for i64/u64.
+    encode: "__SCAFFOLD_RUST_INT64_ENCODE__",
+    decode: "__SCAFFOLD_RUST_INT64_DECODE__",
+    imports: ["use serde_with::DisplayFromStr;"],
+    dep: { name: "serde_with", version: "^3" },
+    mode: "lib"
+  },
+  decimal: {
+    encode: "__SCAFFOLD_RUST_DECIMAL_ENCODE__",
+    decode: "__SCAFFOLD_RUST_DECIMAL_DECODE__",
+    imports: ["use rust_decimal::Decimal;"],
+    dep: { name: "rust_decimal", version: "^1" },
+    mode: "lib"
+  },
+  byte: {
+    // serde_with Base64 attribute.
+    encode: "__SCAFFOLD_RUST_BYTE_ENCODE__",
+    decode: "__SCAFFOLD_RUST_BYTE_DECODE__",
+    imports: ["use serde_with::base64::Base64;"],
+    dep: { name: "serde_with", version: "^3" },
+    mode: "lib"
+  },
+  uuid: {
+    encode: "__SCAFFOLD_RUST_UUID_ENCODE__",
+    decode: "__SCAFFOLD_RUST_UUID_DECODE__",
+    imports: ["use uuid::Uuid;"],
+    dep: { name: "uuid", version: "^1" },
+    mode: "lib"
+  },
+  "number-special": {
+    encode: "__SCAFFOLD_RUST_NUMSPECIAL_ENCODE__",
+    decode: "__SCAFFOLD_RUST_NUMSPECIAL_DECODE__",
+    mode: "native"
+  }
+}, V = {
+  "date-time": {
+    // time.Time serialises as RFC3339Nano via MarshalJSON.
+    encode: "__SCAFFOLD_GO_DATETIME_ENCODE__",
+    decode: "__SCAFFOLD_GO_DATETIME_DECODE__",
+    imports: ['"time"'],
+    mode: "native"
+  },
+  int64: {
+    // struct tag `json:"x,string"` or math/big for arbitrary precision.
+    encode: "__SCAFFOLD_GO_INT64_ENCODE__",
+    decode: "__SCAFFOLD_GO_INT64_DECODE__",
+    imports: ['"strconv"'],
+    mode: "native"
+  },
+  decimal: {
+    encode: "__SCAFFOLD_GO_DECIMAL_ENCODE__",
+    decode: "__SCAFFOLD_GO_DECIMAL_DECODE__",
+    imports: ['"github.com/shopspring/decimal"'],
+    dep: { name: "github.com/shopspring/decimal", version: "v1" },
+    mode: "lib"
+  },
+  byte: {
+    // encoding/base64 — stdlib.
+    encode: "__SCAFFOLD_GO_BYTE_ENCODE__",
+    decode: "__SCAFFOLD_GO_BYTE_DECODE__",
+    imports: ['"encoding/base64"'],
+    mode: "native"
+  },
+  uuid: {
+    encode: "__SCAFFOLD_GO_UUID_ENCODE__",
+    decode: "__SCAFFOLD_GO_UUID_DECODE__",
+    imports: ['"github.com/google/uuid"'],
+    dep: { name: "github.com/google/uuid", version: "v1" },
+    mode: "lib"
+  },
+  "number-special": {
+    encode: "__SCAFFOLD_GO_NUMSPECIAL_ENCODE__",
+    decode: "__SCAFFOLD_GO_NUMSPECIAL_DECODE__",
+    mode: "native"
+  }
+}, Y = {
+  "date-time": {
+    // Instant.toString() / Instant.parse() via jackson-datatype-jsr310.
+    encode: "__SCAFFOLD_JAVA_DATETIME_ENCODE__",
+    decode: "__SCAFFOLD_JAVA_DATETIME_DECODE__",
+    imports: ["import java.time.Instant;"],
+    dep: { name: "jackson-datatype-jsr310", version: "2.x" },
+    mode: "lib"
+  },
+  int64: {
+    // @JsonFormat(shape=STRING) on Long / BigInteger — stdlib Jackson.
+    encode: "__SCAFFOLD_JAVA_INT64_ENCODE__",
+    decode: "__SCAFFOLD_JAVA_INT64_DECODE__",
+    imports: ["import com.fasterxml.jackson.annotation.JsonFormat;"],
+    mode: "native"
+  },
+  decimal: {
+    // @JsonSerialize(using=ToStringSerializer) on BigDecimal — stdlib Jackson.
+    encode: "__SCAFFOLD_JAVA_DECIMAL_ENCODE__",
+    decode: "__SCAFFOLD_JAVA_DECIMAL_DECODE__",
+    imports: ["import java.math.BigDecimal;"],
+    mode: "native"
+  },
+  byte: {
+    // byte[] serialises as base64 by default in Jackson.
+    encode: "__SCAFFOLD_JAVA_BYTE_ENCODE__",
+    decode: "__SCAFFOLD_JAVA_BYTE_DECODE__",
+    mode: "native"
+  },
+  uuid: {
+    // UUID.toString() / UUID.fromString() — stdlib Java.
+    encode: "__SCAFFOLD_JAVA_UUID_ENCODE__",
+    decode: "__SCAFFOLD_JAVA_UUID_DECODE__",
+    imports: ["import java.util.UUID;"],
+    mode: "native"
+  },
+  "number-special": {
+    // Custom StdSerializer — stdlib Jackson.
+    encode: "__SCAFFOLD_JAVA_NUMSPECIAL_ENCODE__",
+    decode: "__SCAFFOLD_JAVA_NUMSPECIAL_DECODE__",
+    mode: "native"
+  }
+}, y = Object.freeze({
+  typescript: B,
+  python: k,
+  rust: J,
+  go: V,
+  java: Y
+});
+function oe(e) {
+  return y[e];
+}
+function ne(e, o) {
+  const t = y[o], n = [];
+  for (const r of e) {
+    const d = t[r];
+    d != null && d.dep && n.push({ id: r, dep: d.dep });
+  }
+  return n;
+}
+function re() {
+  const e = y.typescript, o = {};
+  for (const t of T) {
+    const n = e[t].dep;
+    n && (o[t] = n);
+  }
+  return Object.freeze(o);
+}
+function ie(e, o) {
+  const t = o ?? y[e], n = [];
+  for (const r of T)
+    t[r] || n.push(r);
+  if (n.length > 0)
+    throw new Error(
+      `[hints] assertNoEmptyCells: language "${e}" is missing cells for: ${n.join(
+        ", "
+      )}`
+    );
+}
+export {
+  T as CANONICAL_LOGICAL_TYPE_IDS,
+  g as CodecRegistryError,
+  l as ENVELOPE_KEY,
+  X as LOGICAL_TYPE_VERSION,
+  y as TEMPLATE_CELLS,
+  U as X_APIGEN_CODEC,
+  W as X_APIGEN_CTOR,
+  v as X_APIGEN_LOGICAL,
+  K as X_APIGEN_TOJSON,
+  ie as assertNoEmptyCells,
+  Q as buildTranscoder,
+  $ as byteCodec,
+  oe as cellsFor,
+  Z as codecIdOf,
+  z as createRegistry,
+  b as dateTimeCodec,
+  F as decimalCodec,
+  ne as depsForLogicalTypes,
+  N as int64Codec,
+  H as logicalKindOf,
+  ee as makeDecimal,
+  I as numberSpecialCodec,
+  te as registerWellKnown,
+  x as tryRegister,
+  re as tsDepMap,
+  L as uuidCodec,
+  q as validateSchemaRefs
+};