forge-admin 0.0.0

package/src/orm/migration-engine/diff.ts

@@ -0,0 +1,243 @@
+
+import { db } from "../db/sqlite";
+
+function sameIndex(a: any, b: any) {
+  return (
+    a.unique === b.unique &&
+    a.fields.length === b.fields.length &&
+    a.fields.every((f: string, i: number) => f === b.fields[i])
+  );
+}
+
+
+function getRowCount(table: string): number {
+  const row = db
+    .prepare(`SELECT COUNT(*) as count FROM "${table}"`)
+    .get();
+
+  return row?.count ?? 0;
+}
+
+function validateAddColumn(
+  op: any,
+  existingRowCount: number
+) {
+  const f = op.fieldMeta;
+
+  if (!f.options?.nullable && f.options?.default == null && existingRowCount > 0) {
+    throw new Error(
+      `Cannot add non-nullable field '${f.name}' without a default. ` +
+      `Forge requires either a default or nullable=true.`
+    );
+  }
+}
+
+
+
+function sameFields(a: any, b: any) {
+  const aKeys = Object.keys(a);
+  const bKeys = Object.keys(b);
+
+  if (aKeys.length !== bKeys.length) return false;
+
+  return aKeys.every(key =>
+    b[key] &&
+    a[key].type === b[key].type &&
+    JSON.stringify(a[key].options ?? {}) ===
+      JSON.stringify(b[key].options ?? {})
+  );
+}
+
+export function diffStates(oldState: any, newState: any) {
+  const ops: any[] = [];
+
+  const oldModels = oldState.models;
+  const newModels = newState.models;
+
+  const oldTables = Object.keys(oldModels);
+  const newTables = Object.keys(newModels);
+
+  const removedTables = oldTables.filter(t => !newTables.includes(t));
+  const addedTables = newTables.filter(t => !oldTables.includes(t));
+
+  const consumedOldTables = new Set<string>();
+  const consumedNewTables = new Set<string>();
+
+  // 1️⃣ TABLE RENAME DETECTION
+  for (const oldTable of removedTables) {
+    for (const newTable of addedTables) {
+      if (consumedOldTables.has(oldTable)) continue;
+      if (consumedNewTables.has(newTable)) continue;
+
+      const a = oldModels[oldTable];
+      const b = newModels[newTable];
+
+      if (sameFields(a.fields, b.fields)) {
+        ops.push({
+          type: "RenameTable",
+          from: oldTable,
+          to: newTable,
+        });
+
+        consumedOldTables.add(oldTable);
+        consumedNewTables.add(newTable);
+      }
+    }
+  }
+
+  // 2️⃣ CREATE TABLE
+  for (const table of newTables) {
+    if (oldModels[table]) continue;
+    if (consumedNewTables.has(table)) continue;
+
+    ops.push({
+      type: "CreateTable",
+      meta: newModels[table],
+    });
+  }
+
+  // 3️⃣ DROP TABLE
+  for (const table of oldTables) {
+    if (newModels[table]) continue;
+    if (consumedOldTables.has(table)) continue;
+
+    ops.push({
+      type: "DropTable",
+      model: table,
+    });
+  }
+
+  // 4️⃣ COLUMN-LEVEL DIFFS
+  for (const table of newTables) {
+    if (!oldModels[table]) continue;
+    if (consumedNewTables.has(table)) continue;
+
+    const oldFields = oldModels[table].fields;
+    const newFields = newModels[table].fields;
+
+    const removedFields = Object.keys(oldFields).filter(
+      f => !newFields[f]
+    );
+
+    const addedFields = Object.keys(newFields).filter(
+      f => !oldFields[f]
+    );
+
+    const consumedOldFields = new Set<string>();
+    const consumedNewFields = new Set<string>();
+
+    // 4️⃣a COLUMN RENAME DETECTION
+    for (const oldField of removedFields) {
+      for (const newField of addedFields) {
+        if (consumedOldFields.has(oldField)) continue;
+        if (consumedNewFields.has(newField)) continue;
+
+        const a = oldFields[oldField];
+        const b = newFields[newField];
+
+        if (
+          a.type === b.type &&
+          JSON.stringify(a.options ?? {}) ===
+            JSON.stringify(b.options ?? {})
+        ) {
+          ops.push({
+            type: "RenameColumn",
+            model: table,
+            from: oldField,
+            to: newField,
+          });
+
+          consumedOldFields.add(oldField);
+          consumedNewFields.add(newField);
+        }
+      }
+    }
+
+    // 4️⃣b ADD COLUMN
+    for (const field of addedFields) {
+      if (consumedNewFields.has(field)) continue;
+
+       validateAddColumn(
+        {
+          type: "AddColumn",
+          model: table,
+          field: field,
+          fieldMeta: newFields[field],
+        },
+        getRowCount(table)
+      );
+
+      ops.push({
+        type: "AddColumn",
+        model: table,
+        field,
+        fieldMeta: newFields[field],
+      });
+    }
+
+    // 4️⃣c REMOVE COLUMN
+    for (const field of removedFields) {
+      if (consumedOldFields.has(field)) continue;
+
+      ops.push({
+        type: "RemoveColumn",
+        model: table,
+        field,
+      });
+    }
+  }
+
+  // 5️⃣ INDEX DIFFS
+    const seenCreate = new Set<string>();
+    const seenDelete = new Set<string>();
+    for (const table of newTables) {
+      if (!oldModels[table]) continue;
+
+      const oldIndexes = oldModels[table].indexes ?? [];
+      const newIndexes = newModels[table].indexes ?? [];
+
+      const consumedOld = new Set<number>();
+      const consumedNew = new Set<number>();
+
+      // Detect unchanged / renamed indexes (future-proof)
+      for (let i = 0; i < oldIndexes.length; i++) {
+        for (let j = 0; j < newIndexes.length; j++) {
+          if (consumedOld.has(i) || consumedNew.has(j)) continue;
+
+          if (sameIndex(oldIndexes[i], newIndexes[j])) {
+            consumedOld.add(i);
+            consumedNew.add(j);
+          }
+        }
+      }
+
+      // Added indexes
+      newIndexes.forEach((idx: any, i: number) => {
+        if (consumedNew.has(i)) return;
+        if(!seenCreate.has(idx['name'])){
+          ops.push({
+            type: "CreateIndex",
+            table,
+            index: idx,
+          });
+          seenCreate.add(idx['name']);
+        }
+      });
+
+      // Removed indexes
+      oldIndexes.forEach((idx: any, i: number) => {
+        if (consumedOld.has(i)) return;
+        if(!seenDelete.has(idx['name'])){
+          ops.push({
+            type: "DropIndex",
+            table,
+            index: idx,
+          });
+          seenDelete.add(idx['name']);
+
+        }
+      });
+    }
+
+  return ops;
+}

package/src/orm/migration-engine/operations.ts

@@ -0,0 +1,186 @@
+import { fieldToSQL } from "../db/sql-types";
+import { ModelMeta } from "../metadata/types";
+import { createIndexSQL, dropIndexSQL } from "../db/sql-types";
+import { db } from "../db/sqlite";
+
+function createTableSQL(tableName: string, meta: ModelMeta): string {
+  const columns: string[] = [];
+  const foreignKeys: string[] = [];
+
+  for (const field of Object.values(meta.fields)) {
+    if (field.type === "foreignkey") {
+      columns.push(
+        `"${field.name}" INTEGER ${field.options?.default ? `DEFAULT ${field.options.default}` : "NOT NULL"}`
+      );
+
+      foreignKeys.push(
+        `FOREIGN KEY ("${field.name}") REFERENCES "${field.options.to}"("${field.options.toField}")` +
+        (field.options.onDelete
+          ? ` ON DELETE ${field.options.onDelete}`
+          : "")
+      );
+    } else {
+      columns.push(`"${field.name}" ${fieldToSQL(field)}`);
+    }
+  }
+
+  return `
+CREATE TABLE "${tableName}" (
+  ${[...columns, ...foreignKeys].join(",\n")}
+);
+`;
+}
+
+
+export function rebuildTable(
+  table: string,
+  oldState: ModelMeta,
+  newState: ModelMeta
+): string[] {
+  const tempTable = `${table}__new`;
+
+  const columns = Object.keys(oldState.fields).filter(
+    c => newState.fields[c]
+  );
+
+  const columnList = columns.map(c => `"${c}"`).join(", ");
+
+  return [
+    createTableSQL(tempTable, newState),
+    `
+INSERT INTO "${tempTable}" (${columnList})
+SELECT ${columnList} FROM "${table}";
+`,
+    `DROP TABLE "${table}";`,
+    `ALTER TABLE "${tempTable}" RENAME TO "${table}";`,
+  ];
+}
+
+
+
+export function opToSQL(op: any): string | null {
+  switch (op.type) {
+    case "CreateTable":
+      return createTableSQL(op.meta.tableName, op.meta);
+
+    case "RenameColumn":
+        return `
+            ALTER TABLE ${op.model}
+            RENAME COLUMN ${op.from} TO ${op.to};
+        `;
+
+    case "RenameTable":
+        return `
+            ALTER TABLE "${op.from}"
+            RENAME TO "${op.to}";
+        `;
+
+    
+    case "AddColumn":
+      return `ALTER TABLE ${op.table}
+              ADD COLUMN ${op.field} ${fieldToSQL(op.fieldMeta)};`;
+
+    case "RemoveColumn":
+      return `ALTER TABLE ${op.model}
+              DROP COLUMN ${op.field};`
+
+    case "DropTable":
+      return `DROP TABLE ${op.model};`;
+
+    case "CreateIndex":
+      return createIndexSQL(op.table, op.index);
+
+    case "DropIndex":
+      return dropIndexSQL(op.table, op.index);
+  
+    default:
+      return null;
+  }
+}
+
+
+export function requiresRebuild(op: any): boolean {
+  return [
+    "AddColumn",
+    "RemoveColumn",
+    "RenameColumn",
+    "AddConstraint",
+    "RemoveConstraint",
+    "AlterField",
+  ].includes(op.type);
+}
+
+
+
+
+export function introspectTable(tableName: string): ModelMeta {
+  const columns = db
+    .prepare(`PRAGMA table_info("${tableName}")`)
+    .all();
+
+  const fks = db
+    .prepare(`PRAGMA foreign_key_list("${tableName}")`)
+    .all();
+
+  const fields: any = {};
+
+  for (const col of columns) {
+    fields[col.name] = {
+      name: col.name,
+      type: col.pk === 1 ? "primary" : "string",
+      default: col.default,
+      options: col.options,
+    };
+  }
+
+  for (const fk of fks) {
+    fields[fk.from].type = "foreignkey";
+    fields[fk.from].options = {
+      to: fk.table,
+      toField: fk.to,
+      onDelete: fk.on_delete,
+    };
+  }
+
+  return {
+    tableName,
+    fields,
+    indexes: {},
+    constraints: {},
+  };
+}
+
+export function applyOpToSchema(
+  state: ModelMeta,
+  op: any
+): ModelMeta {
+  const next = structuredClone(state);
+
+  switch (op.type) {
+    case "AddColumn":
+      next.fields[op.field] = op.fieldMeta;
+      break;
+
+    case "RemoveColumn":
+      delete next.fields[op.field];
+      break;
+
+    case "RenameColumn":
+      next.fields[op.to] = {
+        ...next.fields[op.from],
+        name: op.to,
+      };
+      delete next.fields[op.from];
+      break;
+
+    case "AddConstraint":
+      next.constraints[op.constraint.name] = op.constraint;
+      break;
+
+    case "RemoveConstraint":
+      delete next.constraints[op.name];
+      break;
+  }
+
+  return next;
+}

package/src/orm/schema/build.ts

@@ -0,0 +1,138 @@
+import { FieldMeta } from "../metadata/types";
+import { getAllModels, getModelFields } from "../metadata/model-registry";
+import { indexName } from "../metadata";
+
+export function buildSchemaState() {
+    const models: any = {};
+    const modelIndexes: any = {};
+    for (const model of getAllModels()) {
+        const meta = model[Symbol.for("orm:model_meta")];
+        const modelFields = getModelFields(meta.tableName);
+        const fields = modelFields.fields;
+
+        const indexes = [...(meta.indexes ?? [])];
+        for (const field of fields) {
+            // primary key
+            if (field.type === "primary") {
+                indexes.push({
+                name: indexName(meta.tableName, [field.name], true),
+                fields: [field.name],
+                unique: true,
+                });
+            }
+
+            // unique field
+            if (field.options?.unique) {
+                indexes.push({
+                name: indexName(meta.tableName, [field.name], true),
+                fields: [field.name],
+                unique: true,
+                });
+            }
+
+            // foreign key
+            // if (field.type === "foreignkey") {
+            //     indexes.push({
+            //     name: indexName(meta.tableName, [field.name], false),
+            //     fields: [field.name],
+            //     unique: false,
+            //     });
+            // }
+        }
+
+
+        
+        models[meta.tableName] = {
+        tableName: meta.tableName,
+        fields: Object.fromEntries(
+            modelFields.fields.map((f: FieldMeta) => [
+            f.name,
+            {
+                name: f.name,
+                type: f.type,
+                default: f.default ?? null,
+                options: f.options ?? {},
+            },
+            ])
+        ),
+        indexes: indexes,
+        constraints: [],
+        };
+  }
+
+  return {
+    version: 1,
+    dialect: "generic",
+    models,
+  };
+}
+
+export function reverseOp(op: any): any {
+  switch (op.type) {
+    case "AddColumn":
+      return {
+        type: "RemoveColumn",
+        model: op.model,
+        field: op.field,
+      };
+
+    case "RemoveColumn":
+      return {
+        type: "AddColumn",
+        model: op.model,
+        field: op.field,
+        fieldMeta: op.fieldMeta,
+      };
+
+    case "RenameColumn":
+      return {
+        type: "RenameColumn",
+        model: op.model,
+        from: op.to,
+        to: op.from,
+      };
+
+    case "RenameTable":
+      return {
+        type: "RenameTable",
+        from: op.to,
+        to: op.from,
+      };
+
+    case "CreateTable":
+      return {
+        type: "DropTable",
+        model: op.meta.tableName, // ✅ FIX
+      };
+
+    case "DropTable":
+      return {
+        type: "CreateTable",
+        meta: op.meta, // model name is inside meta
+      };
+
+    case "CreateIndex":
+        return {
+            type: "DropIndex",
+            index: op.index
+        };
+
+    case "DropIndex":
+         return {
+            type: "CreateIndex",
+            index: op.index
+        };
+
+
+    case "AddConstraint":
+        return {
+            type: "RemoveConstraint",
+            index: op.index
+        }
+
+        
+    default:
+      throw new Error(`No reverse for ${op.type}`);
+  }
+}
+

package/src/orm/schema/state.ts

@@ -0,0 +1,23 @@
+import fs from "fs";
+import path from "path";
+
+const STATE_PATH = path.resolve("src/orm/migrations/_state.json");
+
+export function loadState() {
+  if (!fs.existsSync(STATE_PATH)) {
+    return {
+      version: 1,
+      dialect: "generic",
+      models: {},
+    };
+  }
+
+  return JSON.parse(fs.readFileSync(STATE_PATH, "utf-8"));
+}
+
+export function saveState(state: any) {
+  fs.writeFileSync(
+    STATE_PATH,
+    JSON.stringify(state, null, 2)
+  );
+}

package/src/orm/schema/writeMigrations.ts

@@ -0,0 +1,21 @@
+import fs from "fs";
+import path from "path";
+
+export function writeMigration(ops: any[]) {
+  if (!ops.length) return null;
+
+  const ts = Date.now();
+  const name = `${ts}_auto.ts`;
+  const file = path.resolve("src/orm/migrations", name);
+
+  fs.writeFileSync(
+    file,
+    `export default {
+  up: ${JSON.stringify(ops, null, 2)},
+  down: [],
+};
+`
+  );
+
+  return name;
+}

package/src/orm/syncdb.ts

@@ -0,0 +1,25 @@
+// orm/syncdb.ts
+import { getAllModels, getModelFields } from "./metadata/model-registry";
+import { getModelMeta } from "./metadata/get-meta";
+import { fieldToSQL } from "./db/sql-types";
+import { db } from "./db/sqlite";
+
+export async function syncdb() {
+  for (const model of getAllModels()) {
+    const meta = getModelMeta(model);
+    const modelFields = getModelFields(meta.tableName)
+    const columns: string[] = [];
+    for (const field of modelFields.fields) {
+      const sqlType = fieldToSQL(field);
+      columns.push(`${field.name} ${sqlType}`);
+    }
+
+    const sql = `
+      CREATE TABLE IF NOT EXISTS ${meta.tableName} (
+        ${columns.join(",\n")}
+      );
+    `;
+
+    db.exec(sql);
+  }
+}