okmodel 0.5.1 → 0.7.0

package/dist/shared/exn3sd90.js

@@ -0,0 +1,359 @@
+import {
+  OkmError2,
+  catalogError2,
+  throwNamed2
+} from "./52szzakm.js";
+
+// src/dialects/pg/morph.ts
+var refuseTo = (planner, schema, relation, child, sink, parent, alias, depth) => {
+  const morph = relation.morph;
+  const typeField = morph?.typeField ?? "type";
+  const idField = morph?.idField ?? "id";
+  throw new OkmError2("OKM1120", `Relation ${relation.name} is a morph. Filter ${typeField} and ${idField}, or include it. has, none, and every are not available on it.`);
+};
+function resolveMorph(scope, name, targets) {
+  const label = `${scope.owner}.${scope.name}`;
+  const owner = described(scope, scope.owner, label);
+  const typeField = `${name}Type`;
+  const idField = `${name}Id`;
+  const typeColumn = requireColumn(owner, typeField, label);
+  const idColumn = requireColumn(owner, idField, label);
+  if (typeColumn.nullable !== idColumn.nullable) {
+    catalogError2("OKM1021", `Relation ${label} columns ${owner.tsName}.${typeColumn.field} and ${owner.tsName}.${idColumn.field} must both be nullable, or neither.`);
+  }
+  if (!isTextType(typeColumn.dataType)) {
+    catalogError2("OKM1022", `Relation ${label} type column ${owner.tsName}.${typeColumn.field} is ${typeColumn.dataType}. Accepted type: text.`);
+  }
+  const seen = new Set;
+  const resolved = [];
+  for (const targetName of targets) {
+    if (seen.has(targetName)) {
+      catalogError2("OKM1023", `Relation ${label} lists ${targetName} twice.`);
+    }
+    seen.add(targetName);
+    if (!scope.tables.includes(targetName)) {
+      throwNamed2("OKM1020", targetName, scope.tables, `Relation ${label} names ${targetName}, which is not in the schema. Accepted names: ${scope.tables.join(", ")}.`);
+    }
+    const target = described(scope, targetName, label);
+    const key = requireKey(target, label, scope.scopeFields);
+    if (idColumn.dataType !== key.dataType) {
+      catalogError2("OKM1022", `Relation ${label} id column ${owner.tsName}.${idColumn.field} is ${idColumn.dataType} and ${target.tsName}.${key.field} is ${key.dataType}. Accepted type: ${key.dataType}.`);
+    }
+    const limit = textLimit(typeColumn.dataType);
+    if (limit !== undefined && targetName.length > limit) {
+      catalogError2("OKM1022", `Relation ${label} type column ${owner.tsName}.${typeColumn.field} is ${typeColumn.dataType} and ${target.tsName} does not fit. Accepted type: text.`);
+    }
+    resolved.push({
+      type: target.tsName,
+      table: target.tsName,
+      sql: target.sqlName,
+      keySql: key.sql
+    });
+  }
+  const first = resolved[0];
+  if (first === undefined) {
+    catalogError2("OKM1020", `Relation ${label} needs a target table.`);
+  }
+  const morph = {
+    direction: "to",
+    name,
+    typeField,
+    idField,
+    typeSql: typeColumn.sqlName,
+    idSql: idColumn.sqlName,
+    targets: resolved
+  };
+  return {
+    name: scope.name,
+    kind: "one",
+    table: first.table,
+    local: [idColumn.sqlName],
+    remote: [first.keySql],
+    morph,
+    through: {
+      table: first.table,
+      local: [idColumn.sqlName],
+      remote: [first.keySql],
+      emit: refuseTo
+    }
+  };
+}
+function resolveMorphMany(scope, table, name) {
+  const label = `${scope.owner}.${scope.name}`;
+  if (!scope.tables.includes(table)) {
+    throwNamed2("OKM1020", table, scope.tables, `Relation ${label} names ${table}, which is not in the schema. Accepted names: ${scope.tables.join(", ")}.`);
+  }
+  const owner = described(scope, table, label);
+  const here = described(scope, scope.owner, label);
+  const targets = declaredTargets(owner.relationOptions, name);
+  if (targets === undefined) {
+    catalogError2("OKM1021", `Relation ${label} needs morph("${name}", [...]) on ${owner.tsName}. ${owner.tsName} has no morph named ${name}.`);
+  }
+  if (!targets.includes(scope.owner)) {
+    catalogError2("OKM1020", `Relation ${label} is not a target of ${owner.tsName}.${name}. Accepted tables: ${targets.join(", ")}.`);
+  }
+  const typeField = `${name}Type`;
+  const idField = `${name}Id`;
+  const typeColumn = requireColumn(owner, typeField, label);
+  const idColumn = requireColumn(owner, idField, label);
+  const key = requireKey(here, label, scope.scopeFields);
+  if (idColumn.dataType !== key.dataType) {
+    catalogError2("OKM1022", `Relation ${label} id column ${owner.tsName}.${idColumn.field} is ${idColumn.dataType} and ${here.tsName}.${key.field} is ${key.dataType}. Accepted type: ${key.dataType}.`);
+  }
+  const morph = {
+    direction: "many",
+    name,
+    typeField,
+    idField,
+    typeSql: typeColumn.sqlName,
+    idSql: idColumn.sqlName,
+    typeValue: here.tsName,
+    targets: [
+      {
+        type: here.tsName,
+        table: here.tsName,
+        sql: here.sqlName,
+        keySql: key.sql
+      }
+    ]
+  };
+  return {
+    name: scope.name,
+    kind: "many",
+    table: owner.tsName,
+    local: [key.sql],
+    remote: [idColumn.sqlName],
+    morph,
+    through: {
+      table: owner.tsName,
+      local: [idColumn.sqlName],
+      remote: [key.sql],
+      emit: morphManyEmit(here.tsName)
+    }
+  };
+}
+function morphManyEmit(typeValue) {
+  return (planner, schema, relation, child, sink, parent, alias) => {
+    const pair = relation.morph;
+    const local = relation.local[0];
+    if (pair === undefined || local === undefined) {
+      throw new OkmError2("OKM1120", `Relation ${relation.name} is not a morph many.`);
+    }
+    const { quote } = planner;
+    sink.text(quote(child.model.sql));
+    sink.text(" ");
+    sink.text(alias);
+    sink.text(" where ");
+    sink.text(alias);
+    sink.text(".");
+    sink.text(quote(pair.typeSql));
+    sink.text(" = ");
+    sink.param(typeValue);
+    sink.text("::text");
+    sink.text(" and ");
+    sink.text(alias);
+    sink.text(".");
+    sink.text(quote(pair.idSql));
+    sink.text(" = ");
+    sink.text(parent);
+    sink.text(".");
+    sink.text(quote(local));
+  };
+}
+function described(scope, table, label) {
+  const found = scope.describe?.(table);
+  if (!isDescribed(found)) {
+    catalogError2("OKM1020", `Relation ${label} names ${table}, which is not in the schema.`);
+  }
+  return found;
+}
+function isDescribed(value) {
+  if (typeof value !== "object" || value === null)
+    return false;
+  if (!("tsName" in value) || typeof value.tsName !== "string")
+    return false;
+  if (!("sqlName" in value) || typeof value.sqlName !== "string")
+    return false;
+  if (!("primary" in value) || !Array.isArray(value.primary))
+    return false;
+  if (!("byField" in value) || !(value.byField instanceof Map))
+    return false;
+  if (!("bySql" in value) || !(value.bySql instanceof Map))
+    return false;
+  return "relationOptions" in value;
+}
+function requireColumn(table, field, label) {
+  const column = table.byField.get(field);
+  if (column === undefined) {
+    catalogError2("OKM1021", `Relation ${label} needs column ${field} on ${table.tsName}.`);
+  }
+  return column;
+}
+function requireKey(table, label, scopeFields) {
+  const skip = scopeFields ?? [];
+  const keys = [];
+  for (const sql of table.primary) {
+    const column = table.bySql.get(sql);
+    if (column === undefined || skip.includes(column.field))
+      continue;
+    keys.push({ field: column.field, sql, dataType: column.dataType });
+  }
+  const only = keys.length === 1 ? keys[0] : undefined;
+  if (only !== undefined)
+    return only;
+  const names = keys.map((key) => key.field);
+  catalogError2("OKM1021", `Relation ${label} cannot use ${table.tsName} as a target. Its primary key is ${names.length === 0 ? "(none)" : names.join(", ")}. A morph id matches one column.`);
+}
+function declaredTargets(options, name) {
+  if (typeof options !== "object" || options === null)
+    return;
+  for (const value of Object.values(options)) {
+    if (typeof value !== "object" || value === null || !("morph" in value))
+      continue;
+    const morph = value.morph;
+    if (morph === undefined || morph.name !== name || !Array.isArray(morph.targets))
+      continue;
+    const names = [];
+    for (const target of morph.targets) {
+      if (typeof target === "string")
+        names.push(target);
+    }
+    return names;
+  }
+  return;
+}
+function assertMorphTo(name, type, id) {
+  if (name === null || type === null || typeof id !== "string" || id.length === 0) {
+    throw new OkmError2("OKM1120", "morphTo() needs a morph name, a target table, and that table's id.");
+  }
+  if (typeof name !== "string" || name.length === 0 || typeof type !== "string" || type.length === 0) {
+    throw new OkmError2("OKM1020", "morphTo() needs a morph name and a target table.");
+  }
+}
+function isTextType(dataType) {
+  return dataType === "text" || dataType === "citext" || dataType.startsWith("varchar(") || dataType.startsWith("character varying(") || dataType.startsWith("char(") || dataType.startsWith("character(");
+}
+function textLimit(dataType) {
+  const match = /^(?:varchar|character varying|char|character)\((\d+)\)$/.exec(dataType);
+  if (match?.[1] === undefined)
+    return;
+  return Number(match[1]);
+}
+
+// src/dialects/pg/through.ts
+var emit = (planner, schema, relation, child, sink, parent, alias, depth) => {
+  const through = relation.through;
+  const join = through === undefined ? undefined : planner.indexes(schema).get(through.table);
+  if (through === undefined || join === undefined) {
+    return catalogError2("OKM1020", `Relation ${relation.name} names a join table that is not in the schema.`);
+  }
+  const { quote } = planner;
+  const joinAlias = `j${alias}`;
+  sink.mark(`via:${through.table}`);
+  sink.text(`${quote(join.model.sql)} ${joinAlias} join ${quote(child.model.sql)} ${alias} on `);
+  for (let index = 0;index < through.local.length; index += 1) {
+    const local = through.local[index];
+    const remote = through.remote[index];
+    if (local === undefined || remote === undefined)
+      continue;
+    if (index > 0)
+      sink.text(" and ");
+    sink.text(`${alias}.${quote(remote)} = ${joinAlias}.${quote(local)}`);
+  }
+  sink.text(" where ");
+  planner.join(sink, parent, joinAlias, relation);
+  planner.where(schema, join, undefined, sink, joinAlias, depth + 1, true);
+};
+function resolveThrough(scope, table, through, from, to) {
+  for (const name of [table, through]) {
+    if (!scope.tables.includes(name)) {
+      throwNamed2("OKM1020", name, scope.tables, `Relation ${scope.owner}.${scope.name} names ${name}, which is not in the schema. Accepted names: ${scope.tables.join(", ")}.`);
+    }
+  }
+  const toOwner = pick(scope, through, scope.owner, from, `${scope.owner}.${scope.name}`, "from");
+  const toTable = pick(scope, through, table, to, `${scope.owner}.${scope.name}`, "to");
+  if (toOwner === toTable) {
+    catalogError2("OKM1021", `Relation ${scope.owner}.${scope.name} uses ${toOwner.fromField} on ${through} for both ends. Pass from and to.`);
+  }
+  return {
+    name: scope.name,
+    kind: "many",
+    table,
+    local: toOwner.remote,
+    remote: toOwner.local,
+    through: { table: through, local: toTable.local, remote: toTable.remote, emit }
+  };
+}
+function pick(scope, through, target, field, label, end) {
+  const matches = scope.edges.filter((edge) => edge.fromTable === through && edge.toTable === target && (field === undefined || edge.fromField === field));
+  const [only] = matches;
+  if (matches.length === 1 && only !== undefined)
+    return only;
+  const fields = matches.map((edge) => edge.fromField).sort();
+  catalogError2("OKM1021", `Relation ${label} through ${through} is ambiguous at ${end}. Accepted columns: ${fields.length === 0 ? "(none)" : fields.join(", ")}.`);
+}
+
+// src/dialects/pg/relations.ts
+function one2(table, field) {
+  return { kind: "one", table, field };
+}
+function many2(table, field) {
+  return { kind: "many", table, field };
+}
+function isRelationCall(value) {
+  if (typeof value !== "object" || value === null)
+    return false;
+  if (!("kind" in value) || !("table" in value))
+    return false;
+  const kind = value.kind;
+  return (kind === "one" || kind === "many") && typeof value.table === "string";
+}
+function manyThrough2(table, options) {
+  const { through, from, to } = options;
+  return {
+    kind: "many",
+    table,
+    field: undefined,
+    through,
+    resolve: (scope) => resolveThrough(scope, table, through, from, to)
+  };
+}
+function morph2(name, targets) {
+  if (name.length === 0)
+    throw new OkmError2("OKM1020", "morph() needs a name.");
+  if (targets.length === 0)
+    throw new OkmError2("OKM1020", "morph() needs a target table.");
+  for (const target of targets) {
+    if (typeof target !== "string" || target.length === 0) {
+      throw new OkmError2("OKM1020", "morph() targets must be table names.");
+    }
+  }
+  const list = targets;
+  return {
+    kind: "one",
+    table: targets[0],
+    field: undefined,
+    morph: { name, targets, typeField: `${name}Type` },
+    resolve: (scope) => resolveMorph(scope, name, list)
+  };
+}
+function morphMany2(table, name) {
+  if (table.length === 0 || name.length === 0) {
+    throw new OkmError2("OKM1020", "morphMany() needs a table and a morph name.");
+  }
+  return {
+    kind: "many",
+    table,
+    field: undefined,
+    resolve: (scope) => resolveMorphMany(scope, table, name)
+  };
+}
+function morphTo2(name, type, id) {
+  assertMorphTo(name, type, id);
+  const row = {};
+  row[`${name}Type`] = type;
+  row[`${name}Id`] = id;
+  return row;
+}
+
+export { one2, many2, isRelationCall, manyThrough2, morph2, morphMany2, morphTo2 };

package/dist/shared/g6evj1j3.js

@@ -0,0 +1,66 @@
+import {
+  mapFailure
+} from "./kb2sdhfb.js";
+
+// src/adapters/pg/pglite-wire.ts
+var OIDS = [
+  16,
+  17,
+  20,
+  21,
+  23,
+  25,
+  114,
+  700,
+  701,
+  1043,
+  1082,
+  1114,
+  1184,
+  1700,
+  2950,
+  3802,
+  1000,
+  1005,
+  1007,
+  1009,
+  1016,
+  1115,
+  1182,
+  1185,
+  1231,
+  199,
+  3807
+];
+function identity(value) {
+  return value;
+}
+function serialize(value) {
+  if (typeof value === "number" || typeof value === "bigint")
+    return String(value);
+  if (typeof value === "boolean")
+    return value ? "t" : "f";
+  return value;
+}
+var parsers = {};
+var serializers = {};
+for (const oid of OIDS) {
+  parsers[oid] = identity;
+  serializers[oid] = serialize;
+}
+function fail(error) {
+  return mapFailure(protocol(error));
+}
+function protocol(error) {
+  if (typeof error !== "object" || error === null || !("code" in error))
+    return error;
+  if (error.code !== "08P01")
+    return error;
+  const message = error instanceof Error ? error.message : "";
+  return new Error(message.length > 0 ? message : "protocol error");
+}
+export {
+  fail,
+  parsers,
+  serializers
+};

package/dist/shared/ga9j92qj.js

@@ -0,0 +1,25 @@
+// src/dialects/pg/floor.ts
+var POSTGRES_FLOOR = 15;
+var UUIDV7_POSTGRES = 18;
+function isPostgresMajor(value) {
+  return typeof value === "number" && (value | 0) === value && value >= 15 && value <= 18;
+}
+var FLOOR_TEXT = /^>=(\d+)$/;
+function parsePostgresFloor(postgres) {
+  return Number(FLOOR_TEXT.exec(postgres ?? "")?.[1]);
+}
+function formatPostgresFloor(major) {
+  return `>=${major}`;
+}
+function minPostgresDefinition() {
+  return "minPostgres: 15-18.";
+}
+function uuidv7NeedsPostgres() {
+  const need = UUIDV7_POSTGRES;
+  return `uuidv7() needs PostgreSQL ${need} or higher. minPostgres: ${need}.`;
+}
+function serverNeedsPostgres(server, need) {
+  return `The server is PostgreSQL ${server}. This schema needs PostgreSQL ${need} or higher (minPostgres: ${need}).`;
+}
+
+export { POSTGRES_FLOOR, UUIDV7_POSTGRES, isPostgresMajor, parsePostgresFloor, formatPostgresFloor, minPostgresDefinition, uuidv7NeedsPostgres, serverNeedsPostgres };