okmodel 0.1.1 → 0.2.1

package/dist/shared/x9v1qgeb.js

@@ -0,0 +1,201 @@
+import {
+  callerLocation,
+  withLocation
+} from "./k7dwkhvq.js";
+import {
+  definition,
+  unavailable
+} from "./xatfg0gn.js";
+import {
+  OkmError2,
+  throwNamed2
+} from "./52szzakm.js";
+
+// src/dialects/pg/filters.ts
+function openFilters(table, relations, spec, hiddenFields) {
+  const allow = spec.allow ?? {};
+  const sort = spec.sort ?? [];
+  for (const field of Object.keys(allow))
+    deny(hiddenFields, table, field);
+  for (const field of sort)
+    deny(hiddenFields, table, field);
+  const nested = spec.relations;
+  if (nested !== undefined) {
+    for (const name of Object.keys(nested)) {
+      const target = relationTable(relations, name);
+      for (const field of nested[name] ?? [])
+        deny(hiddenFields, target, field);
+    }
+  }
+  return {
+    parse(query) {
+      return import("./0v1g424p.js").then((mod) => mod.parseQuery(allow, sort, query));
+    }
+  };
+}
+function deny(hiddenFields, table, field) {
+  if (!hiddenFields.has(`${table}.${field}`))
+    return;
+  throw new OkmError2("OKM1123", `Field ${table}.${field} is hidden.`, {
+    fix: {
+      summary: "Remove the hidden field from the allowlist. Hidden fields stay out of caller filters and sorts."
+    }
+  });
+}
+function relationTable(relations, name) {
+  if (typeof relations !== "object" || relations === null)
+    return name;
+  const call = relations[name];
+  if (typeof call !== "object" || call === null || !("table" in call))
+    return name;
+  const table = call.table;
+  return typeof table === "string" ? table : name;
+}
+
+// src/dialects/pg/table.ts
+var TABLE_KNOWN = new Set([
+  "checks",
+  "comment",
+  "indexes",
+  "omitDefaults",
+  "presets",
+  "primaryKey",
+  "relations",
+  "renamedFrom",
+  "sqlName",
+  "tenancy",
+  "traits",
+  "unique",
+  "validate",
+  "validation"
+]);
+var TABLE_LATER = {
+  computed: "later",
+  policies: "later",
+  reference: "0.4"
+};
+function table2(name, columns, options) {
+  const source = callerLocation(1);
+  if (name.length === 0) {
+    definition(withLocation("table() needs a name.", source));
+  }
+  if (options !== undefined) {
+    rejectLater(options, TABLE_KNOWN, TABLE_LATER, `Table ${name}`);
+  }
+  remember(name, columns);
+  return {
+    name,
+    columns,
+    filters(spec) {
+      return openFilters(name, options?.relations, spec, hiddenFields);
+    },
+    ...options !== undefined ? { options } : {},
+    ...source !== undefined ? { source } : {}
+  };
+}
+function index2(...columns) {
+  return indexCall(columns.map((column) => column.name), false);
+}
+function sql2(strings, ...values) {
+  let text = strings[0] ?? "";
+  for (let index = 0;index < values.length; index += 1) {
+    text += sqlValue(values[index]);
+    text += strings[index + 1] ?? "";
+  }
+  return { text };
+}
+function snakeCase(name) {
+  let out = "";
+  for (let index = 0;index < name.length; index += 1) {
+    const char = name[index] ?? "";
+    const lower = char.toLowerCase();
+    if (lower !== char && char.toUpperCase() === char && out.length > 0 && !out.endsWith("_")) {
+      out += "_";
+    }
+    out += lower;
+  }
+  return out;
+}
+function emittedTypeName(name) {
+  let out = "";
+  let capitalize = true;
+  for (const char of name) {
+    const letter = char >= "a" && char <= "z" || char >= "A" && char <= "Z";
+    const digit = char >= "0" && char <= "9";
+    if (!letter && !digit) {
+      capitalize = true;
+      continue;
+    }
+    if (capitalize && letter) {
+      out += char.toUpperCase();
+      capitalize = false;
+      continue;
+    }
+    out += char;
+    capitalize = false;
+  }
+  if (out.length === 0) {
+    return "Table";
+  }
+  const first = out[0] ?? "";
+  if (first >= "0" && first <= "9") {
+    return `T${out}`;
+  }
+  return out;
+}
+function rejectLater(options, known, later, where) {
+  const record = options;
+  for (const key of Object.keys(record)) {
+    const prompt = later[key];
+    if (prompt !== undefined) {
+      if (record[key] !== undefined) {
+        const when = prompt === "later" ? "later" : `in ${prompt}`;
+        unavailable(`${where} option ${key} is not available yet. It arrives ${when}.`);
+      }
+      continue;
+    }
+    if (!known.has(key)) {
+      const accepted = [...known].sort().join(", ");
+      const candidates = [...known, ...Object.keys(later)];
+      throwNamed2("OKM1060", key, candidates, `${where} option ${key} is not supported. Accepted options: ${accepted}.`);
+    }
+  }
+}
+function indexCall(columns, isUnique, predicate) {
+  return {
+    columns,
+    isUnique,
+    ...predicate !== undefined ? { predicate } : {},
+    unique() {
+      return indexCall(columns, true, predicate);
+    }
+  };
+}
+function sqlValue(value) {
+  if (typeof value === "string") {
+    return value;
+  }
+  if (typeof value === "number" || typeof value === "boolean") {
+    return String(value);
+  }
+  if (value === null || value === undefined) {
+    return "null";
+  }
+  if ("text" in value && typeof value.text === "string") {
+    return value.text;
+  }
+  if ("name" in value && typeof value.name === "string") {
+    return value.name;
+  }
+  definition("sql accepts a column, a string, a number, a boolean, or null.");
+}
+var hiddenFields = new Set;
+function remember(name, columns) {
+  for (const field of Object.keys(columns)) {
+    const column = columns[field];
+    if (column?.state?.hidden === true)
+      hiddenFields.add(`${name}.${field}`);
+  }
+}
+
+export { table2, index2, sql2, snakeCase, emittedTypeName, rejectLater };

package/dist/shared/xatfg0gn.js

@@ -0,0 +1,193 @@
+import {
+  OkmError2
+} from "./52szzakm.js";
+
+// src/dialects/pg/misuse.ts
+var COLUMN_DEFINITION_CODE = "OKM1060";
+var RESERVED_OPTION_CODE = "OKM1061";
+var CODEC_VALUE_CODE = "OKM1210";
+function definition(message) {
+  throw new OkmError2(COLUMN_DEFINITION_CODE, message);
+}
+function unavailable(message) {
+  throw new OkmError2(RESERVED_OPTION_CODE, message);
+}
+function rejected(message) {
+  throw new OkmError2(CODEC_VALUE_CODE, message);
+}
+
+// src/dialects/pg/quote.ts
+function quoteLiteral(value) {
+  return `'${value.replaceAll("'", "''")}'`;
+}
+function arrayElement(encoded, raw) {
+  if (raw && (encoded === "true" || encoded === "false" || isBareNumber(encoded))) {
+    return encoded;
+  }
+  return `"${encoded.replaceAll("\\", "\\\\").replaceAll('"', "\\\"")}"`;
+}
+function isBareNumber(encoded) {
+  let pattern = bareNumber;
+  pattern ??= /^-?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?$/;
+  bareNumber = pattern;
+  return pattern.test(encoded);
+}
+var bareNumber;
+
+// src/dialects/pg/array-literal.ts
+function writeArray(value, dims, encode, raw) {
+  return writeLevel(value, dims, encode, raw);
+}
+function readArray(wire, dims, decode) {
+  const cursor = { text: wire, index: 0 };
+  const parsed = parseValue(cursor);
+  skipSpace(cursor);
+  if (cursor.index !== cursor.text.length) {
+    rejected("Array literal has trailing text.");
+  }
+  if (!Array.isArray(parsed)) {
+    rejected("Array literal must start with `{`.");
+  }
+  return interpret(parsed, dims, decode);
+}
+function writeLevel(value, dims, encode, raw) {
+  if (!Array.isArray(value)) {
+    rejected("Array column expected an array.");
+  }
+  const parts = [];
+  if (dims === 1) {
+    for (const item of value) {
+      if (item === null || item === undefined) {
+        rejected("Array elements cannot be null.");
+      }
+      parts.push(arrayElement(encode(item), raw));
+    }
+  } else {
+    for (const item of value) {
+      parts.push(writeLevel(item, dims - 1, encode, raw));
+    }
+  }
+  return `{${parts.join(",")}}`;
+}
+function interpret(nodes, dims, decode) {
+  if (dims === 1) {
+    return nodes.map((cell) => {
+      if (typeof cell !== "string") {
+        rejected("Array rank does not match dims.");
+      }
+      return decode(cell);
+    });
+  }
+  return nodes.map((cell) => {
+    if (!Array.isArray(cell)) {
+      rejected("Array rank does not match dims.");
+    }
+    return interpret(cell, dims - 1, decode);
+  });
+}
+function parseValue(cursor) {
+  skipSpace(cursor);
+  if (peek(cursor) === "{") {
+    return parseArray(cursor);
+  }
+  return parseElement(cursor);
+}
+function parseArray(cursor) {
+  expectChar(cursor, "{");
+  skipSpace(cursor);
+  if (peek(cursor) === "}") {
+    cursor.index += 1;
+    return [];
+  }
+  const items = [];
+  for (;; ) {
+    items.push(parseValue(cursor));
+    skipSpace(cursor);
+    if (peek(cursor) === ",") {
+      cursor.index += 1;
+      skipSpace(cursor);
+      continue;
+    }
+    expectChar(cursor, "}");
+    return items;
+  }
+}
+function parseElement(cursor) {
+  if (peek(cursor) === '"') {
+    return parseQuoted(cursor);
+  }
+  const start = cursor.index;
+  while (cursor.index < cursor.text.length) {
+    const char = cursor.text[cursor.index];
+    if (char === "," || char === "}" || char === undefined || isSpace(char)) {
+      break;
+    }
+    cursor.index += 1;
+  }
+  const token = cursor.text.slice(start, cursor.index);
+  if (token.length === 0) {
+    rejected("Array literal is missing an element.");
+  }
+  if (token === "NULL") {
+    return null;
+  }
+  return token;
+}
+function parseQuoted(cursor) {
+  expectChar(cursor, '"');
+  let out = "";
+  for (;; ) {
+    const char = next(cursor);
+    if (char === undefined) {
+      rejected("Array literal ended inside a quote.");
+    }
+    if (char === '"') {
+      if (peek(cursor) === '"') {
+        cursor.index += 1;
+        out += '"';
+        continue;
+      }
+      return out;
+    }
+    if (char === "\\") {
+      const escaped = next(cursor);
+      if (escaped === undefined) {
+        rejected("Array literal ended inside an escape.");
+      }
+      out += escaped;
+      continue;
+    }
+    out += char;
+  }
+}
+function expectChar(cursor, expected) {
+  if (peek(cursor) !== expected) {
+    rejected(`Array literal expected ${expected}.`);
+  }
+  cursor.index += 1;
+}
+function peek(cursor) {
+  return cursor.text[cursor.index];
+}
+function next(cursor) {
+  const char = cursor.text[cursor.index];
+  if (char !== undefined) {
+    cursor.index += 1;
+  }
+  return char;
+}
+function skipSpace(cursor) {
+  while (cursor.index < cursor.text.length) {
+    const char = cursor.text[cursor.index];
+    if (char === undefined || !isSpace(char)) {
+      return;
+    }
+    cursor.index += 1;
+  }
+}
+function isSpace(char) {
+  return char === " " || char === `
+` || char === "\t";
+}
+
+export { definition, unavailable, rejected, quoteLiteral, writeArray, readArray };

package/dist/shared/xkz8g6by.js

@@ -0,0 +1,225 @@
+import {
+  required
+} from "./dd4f8mnx.js";
+import {
+  definition,
+  rejected
+} from "./xatfg0gn.js";
+
+// src/dialects/pg/temporal.ts
+var TEMPORAL_MISSING = "Date and time codecs need the Temporal global. okmodel does not ship a polyfill. Use a runtime that provides Temporal, or assign a polyfill to globalThis.Temporal before using these columns.";
+function requireTemporal() {
+  const temporal = globalThis.Temporal;
+  if (typeof temporal !== "object" || temporal === null || !("Instant" in temporal)) {
+    rejected(TEMPORAL_MISSING);
+  }
+}
+function timePrecision(precision, role) {
+  if (precision === undefined) {
+    return;
+  }
+  if (!Number.isInteger(precision) || precision < 0 || precision > 6) {
+    definition(`${role} precision ${String(precision)} must be an integer from 0 to 6.`);
+  }
+  return precision;
+}
+function encodeInstant(value, precision) {
+  requireTemporal();
+  if (precision === undefined) {
+    return value.toString();
+  }
+  return value.toString({ fractionalSecondDigits: precision });
+}
+function decodeInstant(wire) {
+  requireTemporal();
+  try {
+    return Temporal.Instant.from(wire);
+  } catch {
+    rejected(`timestamptz ${wire} must be an ISO-8601 instant, for example 2020-01-01T00:00:00Z.`);
+  }
+}
+function encodeDateTime(value, precision) {
+  requireTemporal();
+  if (precision === undefined) {
+    return value.toString();
+  }
+  return value.toString({ fractionalSecondDigits: precision });
+}
+function decodeDateTime(wire) {
+  requireTemporal();
+  try {
+    return Temporal.PlainDateTime.from(wire);
+  } catch {
+    rejected(`timestamp ${wire} must be an ISO-8601 date-time without a zone, for example 2020-01-01T00:00:00.`);
+  }
+}
+function encodeDate(value) {
+  requireTemporal();
+  return value.toString();
+}
+function decodeDate(wire) {
+  requireTemporal();
+  try {
+    return Temporal.PlainDate.from(wire);
+  } catch {
+    rejected(`date ${wire} must be YYYY-MM-DD.`);
+  }
+}
+function encodeTime(value, precision) {
+  requireTemporal();
+  if (precision === undefined) {
+    return value.toString();
+  }
+  return value.toString({ fractionalSecondDigits: precision });
+}
+function decodeTime(wire) {
+  requireTemporal();
+  try {
+    return Temporal.PlainTime.from(wire);
+  } catch {
+    rejected(`time ${wire} must be a time of day, for example 00:00:00.`);
+  }
+}
+function encodeTimeZone(value, precision) {
+  requireTemporal();
+  if (!offsetText().test(value.offset)) {
+    rejected(`timetz offset ${value.offset} must be ±HH:MM.`);
+  }
+  return `${encodeTime(value.time, precision)}${value.offset}`;
+}
+function decodeTimeZone(wire) {
+  const match = timeZoneText().exec(wire);
+  const time = match?.[1];
+  const hours = match?.[2];
+  if (time === undefined || hours === undefined) {
+    rejected(`timetz ${wire} must be a time of day plus ±HH or ±HH:MM, for example 00:00:00+00.`);
+  }
+  return { time: decodeTime(time), offset: `${hours}:${match?.[3] ?? "00"}` };
+}
+function encodeDuration(value) {
+  requireTemporal();
+  const text = value.toString();
+  return text.startsWith("-") ? text.slice(1).replace(/\d+(?:\.\d+)?(?=[A-Z])/g, "-$&") : text;
+}
+function decodeDuration(wire) {
+  requireTemporal();
+  const fields = {};
+  const rest = wire.replace(/([+-]?\d+) (year|mon|day)s?|([+-]?)(\d+):(\d{2}):(\d{2})(?:\.(\d{1,6}))?/g, (_part, count, unit, sign, h = "", m = "", s = "", f = "") => {
+    if (count !== undefined && unit !== undefined) {
+      fields[`${unit === "mon" ? "month" : unit}s`] = Number(count);
+      return "";
+    }
+    const micros = Number(f.padEnd(6, "0"));
+    const flip = sign === "-" ? -1 : 1;
+    fields.hours = flip * Number(h);
+    fields.minutes = flip * Number(m);
+    fields.seconds = flip * Number(s);
+    fields.milliseconds = flip * Math.trunc(micros / 1000);
+    fields.microseconds = flip * (micros % 1000);
+    return "";
+  });
+  try {
+    return Temporal.Duration.from(rest.trim() === "" && wire !== "" ? fields : wire);
+  } catch {
+    rejected(`interval ${wire} must be what Postgres sends (for example 01:30:00 or 1 day 02:03:04) or an ISO-8601 duration (PT1H). Parts of different signs are not one Temporal.Duration.`);
+  }
+}
+function intervalFields(fields) {
+  switch (fields) {
+    case "year":
+    case "month":
+    case "day":
+    case "hour":
+    case "minute":
+    case "second":
+    case "year to month":
+    case "day to hour":
+    case "day to minute":
+    case "day to second":
+    case "hour to minute":
+    case "hour to second":
+    case "minute to second":
+      return fields;
+    default:
+      definition(`interval fields ${fields} must be one of: year, month, day, hour, minute, second, year to month, day to hour, day to minute, day to second, hour to minute, hour to second, minute to second.`);
+  }
+}
+function offsetText() {
+  offsetPattern ??= /^[+-]\d{2}:\d{2}$/;
+  return offsetPattern;
+}
+function timeZoneText() {
+  timeZonePattern ??= /^(.+?)([+-]\d{2})(?::(\d{2}))?$/;
+  return timeZonePattern;
+}
+var offsetPattern;
+var timeZonePattern;
+
+// src/dialects/pg/time.ts
+function timestamptz2(precision) {
+  const digits = timePrecision(precision, "timestamptz");
+  return required({
+    baseType: timed("timestamptz", digits),
+    encode: (value) => encodeInstant(value, digits),
+    decode: decodeInstant,
+    accepts: ["Temporal.Instant"],
+    sqlForm: "quote"
+  });
+}
+function timestamp2(precision) {
+  const digits = timePrecision(precision, "timestamp");
+  return required({
+    baseType: timed("timestamp", digits),
+    encode: (value) => encodeDateTime(value, digits),
+    decode: decodeDateTime,
+    accepts: ["Temporal.PlainDateTime"],
+    sqlForm: "quote"
+  });
+}
+function date2() {
+  return required({
+    baseType: "date",
+    encode: encodeDate,
+    decode: decodeDate,
+    accepts: ["Temporal.PlainDate"],
+    sqlForm: "quote"
+  });
+}
+function time2(precision) {
+  const digits = timePrecision(precision, "time");
+  return required({
+    baseType: timed("time", digits),
+    encode: (value) => encodeTime(value, digits),
+    decode: decodeTime,
+    accepts: ["Temporal.PlainTime"],
+    sqlForm: "quote"
+  });
+}
+function timetz2(precision) {
+  const digits = timePrecision(precision, "timetz");
+  return required({
+    baseType: timed("timetz", digits),
+    encode: (value) => encodeTimeZone(value, digits),
+    decode: decodeTimeZone,
+    accepts: ["Object"],
+    sqlForm: "quote"
+  });
+}
+function interval2(fields) {
+  const qualifier = fields === undefined ? undefined : intervalFields(fields);
+  return required({
+    baseType: qualifier === undefined ? "interval" : `interval ${qualifier}`,
+    encode: encodeDuration,
+    decode: decodeDuration,
+    accepts: ["Temporal.Duration"],
+    sqlForm: "quote"
+  });
+}
+function timed(name, precision) {
+  if (precision === undefined) {
+    return name;
+  }
+  return `${name}(${String(precision)})`;
+}
+
+export { encodeInstant, decodeInstant, encodeDate, decodeDate, timestamptz2, timestamp2, date2, time2, timetz2, interval2 };