tempest-db-js 0.1.0 → 0.2.0

package/dist/migrations/index.cjs

@@ -1,28 +1,5 @@
 'use strict';
 
-var module$1 = require('module');
-
-var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
-// src/query.ts
-var OPERATORS = [
-  "eq",
-  "ne",
-  "gt",
-  "gte",
-  "lt",
-  "lte",
-  "like",
-  "ilike",
-  "in",
-  "notIn",
-  "between",
-  "isNull"
-];
-
-// src/dialect.ts
-new Set(OPERATORS);
-module$1.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.cjs', document.baseURI).href)));
-
 // src/index.ts
 function isDefaultValue(value) {
   return typeof value === "object" && value !== null && "kind" in value && (value.kind === "literal" || value.kind === "expression");
@@ -76,7 +53,10 @@ var Column = class _Column {
     return new _Column(this.type, this.flags, this.defaultValue, resolved);
   }
 };
+var columnsCache = /* @__PURE__ */ new WeakMap();
 function columnsOf(model) {
+  const cached = columnsCache.get(model);
+  if (cached) return cached;
   const instance = new model();
   const out = {};
   for (const [key, value] of Object.entries(instance)) {
@@ -84,6 +64,7 @@ function columnsOf(model) {
       out[key] = value;
     }
   }
+  columnsCache.set(model, out);
   return out;
 }
 
@@ -257,6 +238,14 @@ function renderColumnDef(col, dialect) {
 function enumTypeName(table, column) {
   return `${table}_${column}`;
 }
+function isAutoIncrementPk(table, col) {
+  return table.primaryKey.length === 1 && table.primaryKey[0] === col.name && col.default === null && (col.type.kind === "smallint" || col.type.kind === "integer" || col.type.kind === "bigint");
+}
+function postgresSerialType(kind) {
+  if (kind === "bigint") return "BIGSERIAL";
+  if (kind === "smallint") return "SMALLSERIAL";
+  return "SERIAL";
+}
 function renderCreateTable(table, dialect) {
   const typeStmts = [];
   const cols = Object.values(table.columns).map((c) => {
@@ -269,6 +258,9 @@ function renderCreateTable(table, dialect) {
       if (c.default !== null) def += ` DEFAULT ${renderDefault(c.default, dialect)}`;
       return def;
     }
+    if (dialect === "postgresql" && isAutoIncrementPk(table, c)) {
+      return `${quoteId(c.name)} ${postgresSerialType(c.type.kind)}`;
+    }
     return renderColumnDef(c, dialect);
   });
   if (table.primaryKey.length > 0) {
@@ -917,13 +909,133 @@ function replaySchema(migrations) {
   return schema;
 }
 
+// src/migrations/renames.ts
+function columnShape(col) {
+  return JSON.stringify({
+    type: col.type,
+    notNull: col.notNull,
+    primaryKey: col.primaryKey,
+    default: col.default
+  });
+}
+function tableShape(columns) {
+  return Object.entries(columns).map(([name, col]) => `${name}:${columnShape(col)}`).sort().join("|");
+}
+function detectRenames(ops) {
+  const candidates = [];
+  const creates = ops.filter((o) => o.kind === "create_table");
+  const tableDrops = ops.filter((o) => o.kind === "drop_table");
+  const takenCreate = /* @__PURE__ */ new Set();
+  const takenDrop = /* @__PURE__ */ new Set();
+  for (const create of creates) {
+    const createShape = tableShape(create.table.columns);
+    const matches = tableDrops.filter(
+      (d) => !takenDrop.has(d.table.name) && tableShape(d.table.columns) === createShape
+    );
+    const uniqueCreate = creates.filter(
+      (c) => !takenCreate.has(c.table.name) && tableShape(c.table.columns) === createShape
+    ).length === 1;
+    if (matches.length === 1 && uniqueCreate) {
+      const drop = matches[0];
+      if (drop.table.name !== create.table.name) {
+        candidates.push({ kind: "table", from: drop.table.name, to: create.table.name });
+        takenCreate.add(create.table.name);
+        takenDrop.add(drop.table.name);
+      }
+    }
+  }
+  const adds = ops.filter((o) => o.kind === "add_column");
+  const colDrops = ops.filter((o) => o.kind === "drop_column");
+  const tables = /* @__PURE__ */ new Set([...adds.map((o) => o.table), ...colDrops.map((o) => o.table)]);
+  for (const table of tables) {
+    const tableAdds = adds.filter((o) => o.table === table);
+    const tableColDrops = colDrops.filter((o) => o.table === table);
+    const takenAdd = /* @__PURE__ */ new Set();
+    const takenColDrop = /* @__PURE__ */ new Set();
+    for (const add of tableAdds) {
+      const shape = columnShape(add.column);
+      const dropMatches = tableColDrops.filter(
+        (d) => !takenColDrop.has(d.column.name) && columnShape(d.column) === shape
+      );
+      const addMatches = tableAdds.filter(
+        (a) => !takenAdd.has(a.column.name) && columnShape(a.column) === shape
+      );
+      if (dropMatches.length === 1 && addMatches.length === 1) {
+        const drop = dropMatches[0];
+        candidates.push({
+          kind: "column",
+          table,
+          from: drop.column.name,
+          to: add.column.name
+        });
+        takenAdd.add(add.column.name);
+        takenColDrop.add(drop.column.name);
+      }
+    }
+  }
+  return candidates;
+}
+function isTableRename(op, r) {
+  return op.kind === "create_table" && op.table.name === r.to || op.kind === "drop_table" && op.table.name === r.from;
+}
+function isColumnRename(op, r) {
+  return op.kind === "add_column" && op.table === r.table && op.column.name === r.to || op.kind === "drop_column" && op.table === r.table && op.column.name === r.from;
+}
+function applyRenames(ops, confirmed) {
+  const out = [];
+  const emitted = /* @__PURE__ */ new Set();
+  for (const op of ops) {
+    const match = confirmed.find(
+      (r) => r.kind === "table" ? isTableRename(op, r) : isColumnRename(op, r)
+    );
+    if (!match) {
+      out.push(op);
+      continue;
+    }
+    if (!emitted.has(match)) {
+      emitted.add(match);
+      out.push(
+        match.kind === "table" ? { kind: "rename_table", from: match.from, to: match.to } : { kind: "rename_column", table: match.table, from: match.from, to: match.to }
+      );
+    }
+  }
+  return out;
+}
+
 // src/migrations/cli.ts
+function defineMigrationConfig(config) {
+  return config;
+}
 function ok(lines) {
   return { code: 0, lines };
 }
 function fail(lines) {
   return { code: 1, lines };
 }
+function parseRenameFlags(rest) {
+  const out = [];
+  for (let i = 0; i < rest.length; i += 1) {
+    const arg = rest[i];
+    if (arg === "--rename-table") {
+      const [from, to] = (rest[i + 1] ?? "").split(":");
+      i += 1;
+      if (from && to) out.push({ kind: "table", from, to });
+    } else if (arg === "--rename-column") {
+      const [left, to] = (rest[i + 1] ?? "").split(":");
+      i += 1;
+      const dot = left?.lastIndexOf(".") ?? -1;
+      if (left && to && dot > 0) {
+        out.push({
+          kind: "column",
+          table: left.slice(0, dot),
+          from: left.slice(dot + 1),
+          to
+        });
+      }
+    }
+  }
+  return out;
+}
 function pending(config, runner) {
   const done = runner.applied();
   return topoOrder(config.migrations).filter((m) => !done.has(m.revision));
@@ -990,7 +1102,11 @@ function runMigrationCli(argv, config) {
       const msgIndex = rest.indexOf("-m");
       const label = msgIndex >= 0 ? rest[msgIndex + 1] ?? "revision" : "revision";
       const parents = heads(config.migrations);
-      const ops = rest.includes("--autogenerate") ? diffSchema(replaySchema(config.migrations), reflectSchema(config.models)) : [];
+      let ops = rest.includes("--autogenerate") ? diffSchema(replaySchema(config.migrations), reflectSchema(config.models)) : [];
+      if (rest.includes("--autogenerate")) {
+        const confirmed = rest.includes("--autorename") ? detectRenames(ops) : parseRenameFlags(rest);
+        if (confirmed.length > 0) ops = applyRenames(ops, confirmed);
+      }
       const source = generateMigration({
         revision: makeRevisionId(label, parents),
         downRevision: parents,
@@ -1013,8 +1129,11 @@ exports.MigrationRunner = MigrationRunner;
 exports.Op = Op;
 exports.UnknownRevision = UnknownRevision;
 exports.applyOperation = applyOperation;
+exports.applyRenames = applyRenames;
 exports.checkDrift = checkDrift;
 exports.checkDriftPostgres = checkDriftPostgres;
+exports.defineMigrationConfig = defineMigrationConfig;
+exports.detectRenames = detectRenames;
 exports.diffSchema = diffSchema;
 exports.emptySchema = emptySchema;
 exports.generateMigration = generateMigration;