okmodel 0.8.0 → 0.9.0

package/dist/shared/n5whk3mt.js

@@ -0,0 +1,665 @@
+import"./12z7aznj.js";
+import"./fk9vef30.js";
+import"./n442h54c.js";
+import"./dd5pmnky.js";
+import {
+  emitPull,
+  formatPullReport,
+  pullLayout2,
+  commitPullFiles2
+} from "./rbxt795q.js";
+import"./myk8fswx.js";
+import {
+  loadConfig
+} from "./2zdxkt7b.js";
+import"./6nae0spm.js";
+import {
+  catalog,
+  enumType
+} from "./ywspezzx.js";
+import {
+  quoteLiteral
+} from "./94ez8kzh.js";
+import {
+  staticNamespace2,
+  table3,
+  column2,
+  index3,
+  constraint2,
+  sequence2
+} from "./358zsv4r.js";
+import {
+  referentialAction
+} from "./4e4c6vq2.js";
+import {
+  OkmError2
+} from "./52szzakm.js";
+
+// src/tooling/migrate/import-drizzle.ts
+import { existsSync, statSync } from "node:fs";
+import { createRequire } from "node:module";
+import { join, resolve } from "node:path";
+import { pathToFileURL } from "node:url";
+var ENUM_SYMBOL = Symbol.for("drizzle:isPgEnum");
+async function importDrizzle(cwd, argv) {
+  const flags = parseImportArgs(argv);
+  const file = readableFile(cwd, flags.path);
+  const drizzle = await loadDrizzle(cwd);
+  const imported = await loadSchemaModule(file);
+  const found = collect(imported, drizzle);
+  if (found.tables.length === 0) {
+    throw new OkmError2("invalid", `${file} exports no Drizzle tables.`, {
+      fix: { summary: "Pass the module that exports pgTable or pgSchema tables." }
+    });
+  }
+  const namespace = chooseNamespace(found.tables, drizzle);
+  const extras = [];
+  const objects = catalogOf(found, drizzle, namespace, extras);
+  const built = catalog(objects);
+  const layout = await layoutFor(cwd, flags.out);
+  const emitted = emitPull(built, layout);
+  const tables = emitted.files.filter((item) => item.path !== layout.schemaFile);
+  if (tables.length === 0) {
+    throw new OkmError2("invalid", "The Drizzle schema has no table okmodel can write.", {
+      fix: { summary: "See the not-imported list. table() has to be able to say the columns." }
+    });
+  }
+  const skipped = [...emitted.skipped, ...extras].sort((left, right) => compare(`${left.kind}\x00${left.label}`, `${right.kind}\x00${right.label}`));
+  commitPullFiles2(emitted.files, "Import");
+  const report = formatPullReport({ tables: tables.length, functions: 0, triggers: 0, views: 0, materializedViews: 0 }, skipped, [], [], "imported");
+  return {
+    text: `namespace ${namespace}
+${report}`,
+    skipped,
+    namespace
+  };
+}
+function parseImportArgs(argv) {
+  let path;
+  let out;
+  for (let index = 0;index < argv.length; index += 1) {
+    const arg = argv[index] ?? "";
+    if (arg === "--out") {
+      const value = argv[index + 1];
+      if (value === undefined || value.startsWith("--")) {
+        throw new OkmError2("invalid", "--out needs a value.", {
+          fix: { summary: "Pass --out <directory>." }
+        });
+      }
+      out = value;
+      index += 1;
+      continue;
+    }
+    if (arg.startsWith("--out=")) {
+      out = arg.slice("--out=".length);
+      continue;
+    }
+    if (arg.startsWith("--")) {
+      throw new OkmError2("invalid", `Unknown flag ${arg}.`, {
+        fix: { summary: "okm import drizzle accepts <path> and --out." }
+      });
+    }
+    if (path !== undefined) {
+      throw new OkmError2("invalid", `Unexpected argument ${arg}.`, {
+        fix: { summary: "Pass one schema path." }
+      });
+    }
+    path = arg;
+  }
+  if (path === undefined || path.length === 0) {
+    throw new OkmError2("invalid", "okm import drizzle needs a path.", {
+      fix: { summary: "Pass the Drizzle schema file." }
+    });
+  }
+  return { path, out };
+}
+function readableFile(cwd, spec) {
+  const path = spec.startsWith("/") ? spec : join(cwd, spec);
+  let info;
+  try {
+    info = statSync(path);
+  } catch (error) {
+    const detail = error instanceof Error ? error.message : "unreadable";
+    throw new OkmError2("invalid", `Cannot read ${path}. ${detail}`, {
+      fix: { summary: "Pass a Drizzle schema file the process can read." }
+    });
+  }
+  if (!info.isFile()) {
+    throw new OkmError2("invalid", `Cannot read ${path}. It is not a file.`, {
+      fix: { summary: "Pass a Drizzle schema file." }
+    });
+  }
+  return path;
+}
+async function loadDrizzle(project) {
+  let pgEntry;
+  let ormEntry;
+  try {
+    const require2 = createRequire(join(resolve(project), "package.json"));
+    pgEntry = require2.resolve("drizzle-orm/pg-core");
+    ormEntry = require2.resolve("drizzle-orm");
+  } catch (error) {
+    throw missingDrizzle(error);
+  }
+  const pg = await import(pathToFileURL(pgEntry).href);
+  const orm = await import(pathToFileURL(ormEntry).href);
+  const is = orm.is;
+  const getTableConfig = pg.getTableConfig;
+  const getTableColumns = orm.getTableColumns;
+  const PgTable = pg.PgTable;
+  const PgView = pg.PgView;
+  const PgMaterializedView = pg.PgMaterializedView;
+  const PgSequence = pg.PgSequence;
+  const Relations = orm.Relations;
+  const getViewConfig = pg.getViewConfig;
+  if (typeof is !== "function" || typeof getTableConfig !== "function" || typeof getTableColumns !== "function" || typeof PgTable !== "function" || typeof PgView !== "function" || typeof PgMaterializedView !== "function" || typeof PgSequence !== "function" || typeof Relations !== "function" || typeof getViewConfig !== "function") {
+    throw new OkmError2("OKM1856", "This project's drizzle-orm has no pg table helpers.", {
+      fix: { summary: "Install a current drizzle-orm in the project that owns the schema." }
+    });
+  }
+  return {
+    is,
+    PgTable,
+    PgView,
+    PgMaterializedView,
+    PgSequence,
+    Relations,
+    getTableConfig,
+    getTableColumns,
+    getViewConfig
+  };
+}
+function missingDrizzle(error) {
+  const detail = error instanceof Error && error.message.length > 0 ? ` ${error.message}` : "";
+  return new OkmError2("OKM1856", `drizzle-orm is not installed in this project.${detail}`, {
+    cause: error,
+    fix: { summary: "Install drizzle-orm in the project that owns the schema." }
+  });
+}
+async function loadSchemaModule(file) {
+  try {
+    const imported = await import(pathToFileURL(file).href);
+    if (typeof imported !== "object" || imported === null)
+      return {};
+    return imported;
+  } catch (error) {
+    if (error instanceof OkmError2)
+      throw error;
+    const detail = error instanceof Error && error.message.length > 0 ? error.message : "failed";
+    throw new OkmError2("invalid", `Importing ${file} failed. ${detail}`, {
+      cause: error,
+      fix: { summary: "The schema file is executed. Fix the error it raised." }
+    });
+  }
+}
+function collect(module, drizzle) {
+  const tables = [];
+  const enums = [];
+  const views = [];
+  const relations = [];
+  const sequences = [];
+  const seen = new Set;
+  const knownTables = new Set;
+  const visit = (value, exportName) => {
+    if (typeof value === "function") {
+      const note = enumNote(value);
+      if (note !== undefined && !enums.some((item) => item.name === note.name))
+        enums.push(note);
+      return;
+    }
+    if (typeof value !== "object" || value === null)
+      return;
+    if (seen.has(value))
+      return;
+    seen.add(value);
+    if (drizzle.is(value, drizzle.PgTable)) {
+      if (!knownTables.has(value)) {
+        knownTables.add(value);
+        tables.push({ value, exportName });
+      }
+      return;
+    }
+    if (drizzle.is(value, drizzle.Relations)) {
+      relations.push(exportName);
+      return;
+    }
+    if (drizzle.is(value, drizzle.PgView) || drizzle.is(value, drizzle.PgMaterializedView)) {
+      views.push(viewName(value, drizzle, exportName));
+      return;
+    }
+    if (drizzle.is(value, drizzle.PgSequence)) {
+      const name = stringField(value, "seqName");
+      if (name !== undefined) {
+        sequences.push({ name, schema: stringField(value, "schema") ?? "public" });
+      }
+      return;
+    }
+    for (const child of Object.values(value))
+      visit(child, exportName);
+  };
+  for (const key of Object.keys(module).sort())
+    visit(module[key], key);
+  tables.sort((left, right) => compare(left.exportName, right.exportName));
+  return { tables, enums, views, relations, sequences };
+}
+function chooseNamespace(tables, drizzle) {
+  const names = new Set(tables.map((item) => drizzle.getTableConfig(item.value).schema ?? "public"));
+  if (names.size === 1)
+    return [...names][0] ?? "public";
+  if (names.has("public"))
+    return "public";
+  return [...names].sort()[0] ?? "public";
+}
+function catalogOf(found, drizzle, namespaceName, extras) {
+  const namespace = staticNamespace2(namespaceName);
+  const objects = [];
+  const enums = new Map;
+  for (const note of found.enums)
+    enums.set(note.name, note.labels);
+  for (const item of found.relations) {
+    extras.push(extra("relation", item, "relations() is not a foreign key"));
+  }
+  for (const item of found.views) {
+    extras.push(extra("view", item, "a later step writes views"));
+  }
+  for (const item of found.sequences) {
+    if (item.schema !== namespaceName) {
+      extras.push(extra("sequence", item.name, "table() has no standalone sequence. An identity column writes its own"));
+      continue;
+    }
+    objects.push(sequence2({
+      namespace,
+      name: item.name,
+      provenance: provenanceOf()
+    }));
+  }
+  for (const item of found.tables) {
+    const config = drizzle.getTableConfig(item.value);
+    const schemaName = config.schema ?? "public";
+    if (schemaName !== namespaceName) {
+      extras.push(extra("table", config.name, "schema() has one namespace. Import that schema on its own and set namespace"));
+      continue;
+    }
+    const parent = { namespace, name: config.name };
+    objects.push(table3({
+      namespace,
+      name: config.name,
+      provenance: provenanceOf(`export:${item.exportName}`)
+    }));
+    if (config.enableRLS) {
+      extras.push(extra("policy", `${config.name}.row level security`, "a later step writes policies"));
+    }
+    for (const policy of config.policies) {
+      const name = policy.name ?? "policy";
+      extras.push(extra("policy", `${config.name}.${name}`, "a later step writes policies"));
+    }
+    const columns = drizzle.getTableColumns(item.value);
+    const primaryColumns = primaryColumnsOf(config, columns);
+    for (const [property, value] of Object.entries(columns)) {
+      const built = columnOf(parent, property, value, primaryColumns, enums, objects, namespace, extras, config.name);
+      if (built !== undefined)
+        objects.push(built);
+    }
+    for (const key of config.primaryKeys) {
+      const names = key.columns.map((entry) => entry.name);
+      if (names.length === 0)
+        continue;
+      if (sameColumns(names, primaryColumns))
+        continue;
+      objects.push(constraint2({
+        parent,
+        constraintKind: "primaryKey",
+        columns: names,
+        nameKey: keyName(key.name, names),
+        provenance: provenanceOf()
+      }));
+    }
+    if (primaryColumns.length > 0) {
+      objects.push(constraint2({
+        parent,
+        constraintKind: "primaryKey",
+        columns: primaryColumns,
+        nameKey: "pkey",
+        provenance: provenanceOf()
+      }));
+    }
+    const uniqueSets = new Set;
+    for (const unique of config.uniqueConstraints) {
+      const names = unique.columns.map((entry) => entry.name);
+      uniqueSets.add(names.join("\x00"));
+      objects.push(constraint2({
+        parent,
+        constraintKind: "unique",
+        columns: names,
+        nameKey: keyName(unique.name, names),
+        nullsNotDistinct: unique.nullsNotDistinct,
+        provenance: provenanceOf()
+      }));
+    }
+    for (const [property, value] of Object.entries(columns)) {
+      if (!flag(value, "isUnique"))
+        continue;
+      const name = stringField(value, "name") ?? property;
+      if (uniqueSets.has(name))
+        continue;
+      objects.push(constraint2({
+        parent,
+        constraintKind: "unique",
+        columns: [name],
+        nameKey: keyName(stringField(value, "uniqueName"), [name]),
+        provenance: provenanceOf()
+      }));
+    }
+    for (const key of config.foreignKeys) {
+      const ref = key.reference();
+      const local = ref.columns.map((entry) => entry.name);
+      const remote = ref.foreignColumns.map((entry) => entry.name);
+      const target = drizzle.getTableConfig(ref.foreignTable);
+      if ((target.schema ?? "public") !== namespaceName) {
+        extras.push(extra("constraint", `${config.name}.${local.join("_")}`, "the referenced table is in another schema"));
+        continue;
+      }
+      const onDelete = action(key.onDelete);
+      const onUpdate = action(key.onUpdate);
+      objects.push(constraint2({
+        parent,
+        constraintKind: "foreignKey",
+        columns: local,
+        nameKey: keyName(undefined, local),
+        provenance: provenanceOf(),
+        references: {
+          parent: { namespace, name: target.name },
+          columns: remote,
+          ...onDelete !== undefined ? { onDelete } : {},
+          ...onUpdate !== undefined ? { onUpdate } : {}
+        }
+      }));
+    }
+    for (const check of config.checks) {
+      const rendered = sqlText(check.value);
+      if (rendered === undefined) {
+        extras.push(extra("constraint", `${config.name}.${check.name}`, "the check expression could not be read"));
+        continue;
+      }
+      objects.push(constraint2({
+        parent,
+        constraintKind: "check",
+        columns: namesIn(check.value),
+        nameKey: keyName(check.name, [check.name]),
+        expression: rendered,
+        provenance: provenanceOf()
+      }));
+    }
+    for (const item of config.indexes) {
+      const unsupported = item.config.concurrently === true || item.config.only === true || item.config.method !== undefined && item.config.method !== "btree" || item.config.with !== undefined;
+      const label = `${config.name}.${item.config.name ?? "index"}`;
+      if (unsupported) {
+        extras.push(extra("index", label, "index() cannot store concurrently, only, a non-btree method, or storage parameters"));
+        continue;
+      }
+      const names = item.config.columns.map((entry) => stringField(entry, "name")).filter((name) => name !== undefined);
+      const expression = item.config.columns.filter((entry) => stringField(entry, "name") === undefined).map((entry) => sqlText(entry)).find((text) => text !== undefined);
+      const predicate = item.config.where === undefined ? undefined : sqlText(item.config.where);
+      if (names.length === 0 && expression === undefined) {
+        extras.push(extra("index", label, "index() needs a column. This index is an expression"));
+        continue;
+      }
+      if (predicate === undefined && item.config.where !== undefined) {
+        extras.push(extra("index", label, "the index predicate could not be read"));
+        continue;
+      }
+      objects.push(index3({
+        parent,
+        columns: names,
+        unique: item.config.unique,
+        nameKey: keyName(item.config.name, names.length > 0 ? names : ["expr"]),
+        ...predicate !== undefined ? { predicate } : {},
+        ...expression !== undefined ? { expression } : {},
+        provenance: provenanceOf()
+      }));
+    }
+  }
+  for (const [name, labels] of enums) {
+    objects.push(enumType({
+      namespace,
+      name,
+      labels,
+      provenance: provenanceOf()
+    }));
+  }
+  return objects;
+}
+function columnOf(parent, property, value, primaryColumns, enums, objects, namespace, extras, tableName) {
+  const sqlName = stringField(value, "name") ?? property;
+  const rawType = sqlType(value);
+  if (rawType === undefined)
+    return;
+  const mapped = catalogType(rawType);
+  const note = enumNote(recordField(value, "enum"));
+  if (note !== undefined)
+    enums.set(note.name, note.labels);
+  const identity = identityOf(value);
+  const generated = generatedOf(value);
+  const serial = mapped.serial;
+  if (serial) {
+    const dataType = mapped.dataType === "smallint" || mapped.dataType === "bigint" ? mapped.dataType : "integer";
+    objects.push(sequence2({
+      namespace,
+      name: `${parent.name}_${sqlName}_seq`,
+      dataType,
+      provenance: provenanceOf(),
+      dependencies: [{ kind: "table", namespace, name: parent.name }]
+    }));
+  }
+  const defaultExpression = serial || identity !== undefined || generated !== undefined ? undefined : readDefault(value, extras, `${tableName}.${sqlName}`);
+  const nullable = flag(value, "notNull") ? false : true;
+  const dataType = note !== undefined ? note.name : mapped.dataType;
+  const solePrimary = identity?.always === true && dataType === "bigint" && !nullable && primaryColumns.length === 1 && primaryColumns[0] === sqlName;
+  return column2({
+    parent,
+    name: sqlName,
+    dataType,
+    nullable: solePrimary ? false : nullable,
+    provenance: provenanceOf(`field:${property}`),
+    ...defaultExpression !== undefined ? { defaultExpression } : {},
+    ...identity !== undefined ? { identity } : {},
+    ...generated !== undefined ? { generated } : {},
+    ...note !== undefined ? { dependencies: [{ kind: "type", namespace, name: note.name }] } : {}
+  });
+}
+function primaryColumnsOf(config, columns) {
+  const declared = config.primaryKeys[0];
+  if (declared !== undefined && declared.columns.length > 0) {
+    return declared.columns.map((entry) => entry.name);
+  }
+  const names = [];
+  for (const value of Object.values(columns)) {
+    if (flag(value, "primary")) {
+      const name = stringField(value, "name");
+      if (name !== undefined)
+        names.push(name);
+    }
+  }
+  return names;
+}
+function catalogType(sqlType) {
+  if (sqlType === "serial")
+    return { dataType: "integer", serial: true };
+  if (sqlType === "bigserial")
+    return { dataType: "bigint", serial: true };
+  if (sqlType === "smallserial")
+    return { dataType: "smallint", serial: true };
+  if (sqlType === "timestamp")
+    return { dataType: "timestamp without time zone", serial: false };
+  if (sqlType === "time")
+    return { dataType: "time without time zone", serial: false };
+  return { dataType: sqlType, serial: false };
+}
+function identityOf(value) {
+  const identity = recordField(value, "generatedIdentity");
+  if (typeof identity !== "object" || identity === null)
+    return;
+  const type = stringField(identity, "type");
+  if (type === "always")
+    return { always: true };
+  if (type === "byDefault")
+    return { always: false };
+  return;
+}
+function generatedOf(value) {
+  const generated = recordField(value, "generated");
+  if (typeof generated !== "object" || generated === null)
+    return;
+  const expression = sqlText(recordField(generated, "as"));
+  if (expression === undefined || expression.length === 0)
+    return;
+  const mode = stringField(generated, "mode");
+  return { stored: mode !== "virtual", expression };
+}
+function readDefault(value, extras, label) {
+  const hasFn = typeof recordField(value, "defaultFn") === "function";
+  const raw = recordField(value, "default");
+  if (raw === undefined) {
+    if (hasFn)
+      extras.push(extra("column", label, "a client default is not a SQL default"));
+    return;
+  }
+  const rendered = sqlText(raw);
+  if (rendered === undefined || rendered.length === 0) {
+    extras.push(extra("column", label, "the default expression could not be read"));
+    return;
+  }
+  return rendered;
+}
+function sqlType(value) {
+  if (!("getSQLType" in value) || typeof value.getSQLType !== "function")
+    return;
+  const type = value.getSQLType.call(value);
+  return typeof type === "string" && type.length > 0 ? type : undefined;
+}
+function sqlText(value) {
+  if (typeof value === "string")
+    return quoteLiteral(value);
+  if (typeof value === "boolean")
+    return value ? "true" : "false";
+  if (typeof value === "number" && Number.isFinite(value))
+    return String(value);
+  if (value === null)
+    return "null";
+  if (typeof value !== "object")
+    return;
+  const chunks = recordField(value, "queryChunks");
+  if (!Array.isArray(chunks))
+    return;
+  let text = "";
+  for (const chunk of chunks) {
+    if (typeof chunk !== "object" || chunk === null)
+      return;
+    const literal = recordField(chunk, "value");
+    if (Array.isArray(literal) && typeof literal[0] === "string") {
+      text += literal[0];
+      continue;
+    }
+    const name = stringField(chunk, "name");
+    if (name !== undefined) {
+      text += `"${name.replaceAll('"', '""')}"`;
+      continue;
+    }
+    return;
+  }
+  return text;
+}
+function namesIn(value) {
+  if (typeof value !== "object" || value === null)
+    return [];
+  const chunks = recordField(value, "queryChunks");
+  if (!Array.isArray(chunks))
+    return [];
+  const names = [];
+  for (const chunk of chunks) {
+    const name = typeof chunk === "object" && chunk !== null ? stringField(chunk, "name") : undefined;
+    if (name !== undefined && !names.includes(name))
+      names.push(name);
+  }
+  return names;
+}
+function enumNote(value) {
+  if (typeof value !== "function" && (typeof value !== "object" || value === null))
+    return;
+  if (typeof value === "function" && (!(ENUM_SYMBOL in value) || value[ENUM_SYMBOL] !== true)) {
+    return;
+  }
+  if (typeof value === "object" && value !== null && !("enumName" in value))
+    return;
+  const name = stringField(value, "enumName");
+  const labels = recordField(value, "enumValues");
+  if (name === undefined || !Array.isArray(labels))
+    return;
+  const strings = labels.filter((label) => typeof label === "string");
+  if (strings.length === 0)
+    return;
+  return { name, labels: strings };
+}
+function action(value) {
+  if (value === undefined || value === "no action")
+    return;
+  return referentialAction(value);
+}
+function keyName(name, columns) {
+  if (name !== undefined && /^[A-Za-z_][A-Za-z0-9_]*$/.test(name))
+    return name;
+  const joined = columns.join("_");
+  if (/^[A-Za-z_][A-Za-z0-9_]*$/.test(joined))
+    return joined;
+  return "key";
+}
+function sameColumns(left, right) {
+  if (left.length !== right.length)
+    return false;
+  return left.every((name, index) => name === right[index]);
+}
+function provenanceOf(source) {
+  return source === undefined ? { origin: "file", name: "drizzle" } : { origin: "file", name: "drizzle", source };
+}
+function extra(kind, label, reason) {
+  return { key: `import:${kind}:${label}`, kind, label, reason, sql: "" };
+}
+function viewName(value, drizzle, fallback) {
+  try {
+    const config = drizzle.getViewConfig(value);
+    return config.name ?? fallback;
+  } catch {
+    return fallback;
+  }
+}
+function flag(value, key) {
+  return recordField(value, key) === true;
+}
+function stringField(value, key) {
+  const field = recordField(value, key);
+  return typeof field === "string" && field.length > 0 ? field : undefined;
+}
+function recordField(value, key) {
+  if (!Object.prototype.hasOwnProperty.call(value, key))
+    return;
+  return value[key];
+}
+async function layoutFor(cwd, out) {
+  if (out !== undefined)
+    return pullLayout2(cwd, "schema.ts", "tables", out);
+  const configPath = join(cwd, "okmodel.config.ts");
+  if (!existsSync(configPath))
+    return pullLayout2(cwd, "schema.ts", "tables", undefined);
+  const config = await loadConfig(cwd);
+  return pullLayout2(cwd, config.schema, config.tables, undefined);
+}
+function compare(left, right) {
+  if (left < right)
+    return -1;
+  if (left > right)
+    return 1;
+  return 0;
+}
+export {
+  importDrizzle
+};