okmodel 0.1.1 → 0.2.1

package/dist/shared/gk7cs7sp.js

@@ -1,566 +0,0 @@
-import {
-  REFERENTIAL_ACTIONS,
-  referentialAction
-} from "./j5cn2963.js";
-import {
-  OkmError2,
-  throwNamed2
-} from "./ycwz42az.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";
-}
-
-// src/dialects/pg/column.ts
-class ColumnBuilder2 {
-  state;
-  constructor(state) {
-    this.state = state;
-  }
-  encode(value) {
-    return this.state.encode(value);
-  }
-  decode(wire) {
-    return this.state.decode(wire);
-  }
-  nullable() {
-    return rebuild(this.state, { nullable: true });
-  }
-  default(value) {
-    if (value === null && this.state.nullable === false) {
-      definition("A null default is only accepted on a nullable column. Call .nullable() first.");
-    }
-    if (this.state.picklist !== undefined && value !== null) {
-      const text = String(value);
-      if (!this.state.picklist.values.includes(text)) {
-        definition(`Default ${text} is not in the picklist ${this.state.picklist.values.join(", ")}.`);
-      }
-    }
-    return rebuild(this.state, {
-      hasDefault: true,
-      defaultSql: value === null ? "NULL" : sqlOf(this.state, value),
-      defaultValue: value,
-      generated: undefined
-    });
-  }
-  defaultSql(expression) {
-    if (expression.length === 0) {
-      definition("defaultSql must be a non-empty SQL expression.");
-    }
-    return rebuild(this.state, {
-      hasDefault: true,
-      defaultSql: expression,
-      defaultValue: undefined,
-      generated: undefined
-    });
-  }
-  unique(options) {
-    return rebuild(this.state, {
-      unique: { reason: options?.reason, global: options?.global }
-    });
-  }
-  picklist(values, options) {
-    if (values.length === 0) {
-      definition("A picklist must contain at least one value.");
-    }
-    const allowed = new Set;
-    for (const value of values) {
-      if (value.length === 0) {
-        definition("Picklist values must be non-empty strings.");
-      }
-      if (allowed.has(value)) {
-        definition(`Picklist value ${value} is repeated. Each value is accepted once.`);
-      }
-      allowed.add(value);
-    }
-    if (typeof this.state.defaultValue === "string" && !allowed.has(this.state.defaultValue)) {
-      definition(`Default ${this.state.defaultValue} is not in the picklist ${values.join(", ")}.`);
-    }
-    const previous = this.state.elementEncode;
-    const elementEncode = (value) => {
-      if (typeof value !== "string" || !allowed.has(value)) {
-        rejected(`Picklist rejected ${String(value)}. Accepted values: ${[...allowed].join(", ")}.`);
-      }
-      return previous(value);
-    };
-    return rebuild(this.state, {
-      picklist: { values: values.slice(), check: options?.check !== false },
-      elementEncode,
-      encode: elementEncode
-    });
-  }
-  generated(expression, options) {
-    if (expression.length === 0) {
-      definition("generated() must be a non-empty SQL expression.");
-    }
-    return rebuild(this.state, {
-      generated: { stored: options?.stored !== false, expression },
-      hasDefault: true,
-      defaultSql: undefined,
-      defaultValue: undefined
-    });
-  }
-  guarded() {
-    return rebuild(this.state, { guarded: true });
-  }
-  hidden() {
-    return rebuild(this.state, { hidden: true });
-  }
-  references(table, options) {
-    if (table.length === 0) {
-      definition("references() needs a table name.");
-    }
-    const onDelete = readAction(options?.onDelete, "onDelete");
-    const onUpdate = readAction(options?.onUpdate, "onUpdate");
-    const columns = readReferenceColumns(options?.columns);
-    return rebuild(this.state, {
-      references: {
-        table,
-        ...onDelete !== undefined ? { onDelete } : {},
-        ...onUpdate !== undefined ? { onUpdate } : {},
-        ...columns !== undefined ? { columns } : {}
-      }
-    });
-  }
-  renamedFrom(name) {
-    if (name.length === 0) {
-      definition("renamedFrom must be a non-empty previous column name.");
-    }
-    return rebuild(this.state, { renamedFrom: name });
-  }
-  sqlName(name) {
-    if (name.length === 0) {
-      definition("sqlName must be a non-empty SQL identifier.");
-    }
-    return rebuild(this.state, { sqlName: name });
-  }
-  comment(text) {
-    return rebuild(this.state, { comment: text });
-  }
-  array(options) {
-    if (this.state.dims !== 0) {
-      definition("array() accepts a scalar column. This column is already an array.");
-    }
-    const dims = options?.dims ?? 1;
-    if (!Number.isInteger(dims) || dims < 1 || dims > 6) {
-      definition(`Array dims ${String(dims)} must be an integer from 1 to 6.`);
-    }
-    const elementEncode = this.state.elementEncode;
-    const elementDecode = this.state.elementDecode;
-    const raw = this.state.sqlForm === "raw";
-    return rebuild(this.state, {
-      dims,
-      encode: (value) => writeArray(value, dims, elementEncode, raw),
-      decode: (wire) => readArray(wire, dims, elementDecode)
-    });
-  }
-}
-function required(body) {
-  return openColumn({
-    nullable: false,
-    hasDefault: false,
-    generated: false,
-    guarded: false,
-    hidden: false,
-    omitWrite: false,
-    ...body
-  });
-}
-function openColumn(input) {
-  const elementEncode = input.encode;
-  const elementDecode = input.decode;
-  return new ColumnBuilder2({
-    baseType: input.baseType,
-    dims: 0,
-    nullable: input.nullable,
-    hasDefault: input.hasDefault,
-    defaultSql: input.defaultSql,
-    defaultValue: undefined,
-    identity: input.identity,
-    generated: undefined,
-    unique: undefined,
-    picklist: undefined,
-    guarded: input.guarded,
-    hidden: input.hidden,
-    omitWrite: input.omitWrite,
-    renamedFrom: undefined,
-    sqlName: undefined,
-    comment: undefined,
-    extension: input.extension,
-    typeDependency: input.typeDependency,
-    enumLabels: input.enumLabels,
-    domain: input.domain,
-    primaryKey: input.primaryKey === true,
-    typeLabel: input.typeLabel,
-    references: undefined,
-    validate: undefined,
-    sqlForm: input.sqlForm,
-    encode: input.encode,
-    decode: input.decode,
-    elementEncode,
-    elementDecode
-  });
-}
-function formatType(baseType, dims) {
-  if (dims === 0) {
-    return baseType;
-  }
-  return baseType + "[]".repeat(dims);
-}
-function sqlOf(state, value) {
-  const encoded = state.encode(value);
-  const typed = formatType(state.baseType, state.dims);
-  if (state.sqlForm === "cast") {
-    return `${quoteLiteral(encoded)}::${typed}`;
-  }
-  if (state.sqlForm === "json") {
-    return `${quoteLiteral(encoded)}::json`;
-  }
-  if (state.sqlForm === "jsonb") {
-    return `${quoteLiteral(encoded)}::jsonb`;
-  }
-  if (state.dims > 0 || state.sqlForm === "quote") {
-    return quoteLiteral(encoded);
-  }
-  return encoded;
-}
-function readAction(action, role) {
-  if (action === undefined) {
-    return;
-  }
-  if (referentialAction(action) === undefined) {
-    definition(`references() ${role} ${action} is not a referential action. Accepted actions: ${REFERENTIAL_ACTIONS.join(", ")}.`);
-  }
-  return action;
-}
-function readReferenceColumns(columns) {
-  if (columns === undefined) {
-    return;
-  }
-  if (columns.length === 0) {
-    definition("references() columns must name at least one target column.");
-  }
-  const copy = [];
-  for (const name of columns) {
-    if (name.length === 0) {
-      definition("references() columns must be non-empty names.");
-    }
-    copy.push(name);
-  }
-  return copy;
-}
-function rebuild(state, patch) {
-  return new ColumnBuilder2({ ...state, ...patch });
-}
-
-// src/dialects/pg/table.ts
-var TABLE_KNOWN = new Set([
-  "checks",
-  "comment",
-  "indexes",
-  "relations",
-  "renamedFrom",
-  "sqlName",
-  "unique"
-]);
-var TABLE_LATER = {
-  computed: "later",
-  omitDefaults: "0.2",
-  policies: "later",
-  presets: "0.2",
-  reference: "0.4",
-  tenancy: "0.2",
-  traits: "0.2",
-  validate: "0.2",
-  validation: "0.2"
-};
-function table2(name, columns, options) {
-  if (name.length === 0) {
-    definition("table() needs a name.");
-  }
-  if (options !== undefined) {
-    rejectLater(options, TABLE_KNOWN, TABLE_LATER, `Table ${name}`);
-  }
-  return { name, columns, ...options !== undefined ? { options } : {} };
-}
-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) {
-  return {
-    columns,
-    isUnique,
-    unique() {
-      return indexCall(columns, true);
-    }
-  };
-}
-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.");
-}
-
-export { definition, unavailable, rejected, quoteLiteral, ColumnBuilder2, required, openColumn, formatType, table2, index2, sql2, snakeCase, emittedTypeName, rejectLater };