forge-sql-orm 2.0.9 → 2.0.11

package/dist/ForgeSQLORM.mjs

@@ -1,10 +1,10 @@
-import { sql, isTable, eq, and } from "drizzle-orm";
+import { isTable, sql, eq, and } from "drizzle-orm";
 import moment from "moment";
 import { getTableName } from "drizzle-orm/table";
 import { isSQLWrapper } from "drizzle-orm/sql/sql";
 import { sql as sql$1, migrationRunner } from "@forge/sql";
 import { drizzle } from "drizzle-orm/mysql-proxy";
-import { customType } from "drizzle-orm/mysql-core";
+import { customType, mysqlTable, timestamp, varchar, bigint } from "drizzle-orm/mysql-core";
 import moment$1 from "moment/moment.js";
 const parseDateTime = (value, format) => {
   const m = moment(value, format, true);
@@ -129,32 +129,36 @@ function generateDropTableStatements(tables) {
   dropStatements.push(`DELETE FROM __migrations;`);
   return dropStatements;
 }
-function mapSelectTableToAlias(table) {
+function mapSelectTableToAlias(table, aliasMap) {
   const { columns, tableName } = getTableMetadata(table);
   const selectionsTableFields = {};
   Object.keys(columns).forEach((name) => {
     const column = columns[name];
-    const fieldAlias = sql.raw(`${tableName}_${column.name}`);
+    const uniqName = `a_${tableName}_${column.name}`;
+    const fieldAlias = sql.raw(uniqName);
     selectionsTableFields[name] = sql`${column} as \`${fieldAlias}\``;
+    aliasMap[uniqName] = column;
   });
   return selectionsTableFields;
 }
 function isDrizzleColumn(column) {
   return column && typeof column === "object" && "table" in column;
 }
-function mapSelectAllFieldsToAlias(selections, name, fields) {
+function mapSelectAllFieldsToAlias(selections, name, fields, aliasMap) {
   if (isTable(fields)) {
-    selections[name] = mapSelectTableToAlias(fields);
+    selections[name] = mapSelectTableToAlias(fields, aliasMap);
   } else if (isDrizzleColumn(fields)) {
     const column = fields;
-    let aliasName = sql.raw(`${getTableName(column.table)}_${column.name}`);
+    const uniqName = `a_${getTableName(column.table)}_${column.name}`;
+    let aliasName = sql.raw(uniqName);
     selections[name] = sql`${column} as \`${aliasName}\``;
+    aliasMap[uniqName] = column;
   } else if (isSQLWrapper(fields)) {
     selections[name] = fields;
   } else {
     const innerSelections = {};
     Object.entries(fields).forEach(([iname, ifields]) => {
-      mapSelectAllFieldsToAlias(innerSelections, iname, ifields);
+      mapSelectAllFieldsToAlias(innerSelections, iname, ifields, aliasMap);
     });
     selections[name] = innerSelections;
   }
@@ -164,11 +168,65 @@ function mapSelectFieldsWithAlias(fields) {
   if (!fields) {
     throw new Error("fields is empty");
   }
+  const aliasMap = {};
   const selections = {};
   Object.entries(fields).forEach(([name, fields2]) => {
-    mapSelectAllFieldsToAlias(selections, name, fields2);
+    mapSelectAllFieldsToAlias(selections, name, fields2, aliasMap);
+  });
+  return { selections, aliasMap };
+}
+function getAliasFromDrizzleAlias(value) {
+  const isSQL = value !== null && typeof value === "object" && isSQLWrapper(value) && "queryChunks" in value;
+  if (isSQL) {
+    const sql2 = value;
+    const queryChunks = sql2.queryChunks;
+    if (queryChunks.length > 3) {
+      const aliasNameChunk = queryChunks[queryChunks.length - 2];
+      if (isSQLWrapper(aliasNameChunk) && "queryChunks" in aliasNameChunk) {
+        const aliasNameChunkSql = aliasNameChunk;
+        if (aliasNameChunkSql && aliasNameChunkSql.queryChunks.length === 1) {
+          const queryChunksStringChunc = aliasNameChunkSql.queryChunks[0];
+          if (queryChunksStringChunc && "value" in queryChunksStringChunc) {
+            const values = queryChunksStringChunc.value;
+            if (values && values.length === 1) {
+              return values[0];
+            }
+          }
+        }
+      }
+    }
+  }
+  return void 0;
+}
+function transformValue(value, alias, aliasMap) {
+  const column = aliasMap[alias];
+  if (!column) return value;
+  let customColumn = column;
+  const fromDriver = customColumn?.mapFrom;
+  if (fromDriver && value !== null && value !== void 0) {
+    return fromDriver(value);
+  }
+  return value;
+}
+function transformObject(obj, selections, aliasMap) {
+  const result = {};
+  for (const [key, value] of Object.entries(obj)) {
+    const selection = selections[key];
+    const alias = getAliasFromDrizzleAlias(selection);
+    if (alias && aliasMap[alias]) {
+      result[key] = transformValue(value, alias, aliasMap);
+    } else if (selection && typeof selection === "object" && !isSQLWrapper(selection)) {
+      result[key] = transformObject(value, selection, aliasMap);
+    } else {
+      result[key] = value;
+    }
+  }
+  return result;
+}
+function applyFromDriverTransform(rows, selections, aliasMap) {
+  return rows.map((row) => {
+    return transformObject(row, selections, aliasMap);
   });
-  return selections;
 }
 class ForgeSQLCrudOperations {
   forgeOperations;
@@ -547,6 +605,52 @@ const forgeDriver = async (query, params, method) => {
     throw error;
   }
 };
+function createAliasedSelectBuilder(db, fields, selectFn) {
+  const { selections, aliasMap } = mapSelectFieldsWithAlias(fields);
+  const builder = selectFn(selections);
+  const wrapBuilder = (rawBuilder) => {
+    return new Proxy(rawBuilder, {
+      get(target, prop, receiver) {
+        if (prop === "execute") {
+          return async (...args) => {
+            const rows = await target.execute(...args);
+            return applyFromDriverTransform(rows, selections, aliasMap);
+          };
+        }
+        if (prop === "then") {
+          return (onfulfilled, onrejected) => target.execute().then(
+            (rows) => {
+              const transformed = applyFromDriverTransform(rows, selections, aliasMap);
+              return onfulfilled?.(transformed);
+            },
+            onrejected
+          );
+        }
+        const value = Reflect.get(target, prop, receiver);
+        if (typeof value === "function") {
+          return (...args) => {
+            const result = value.apply(target, args);
+            if (typeof result === "object" && result !== null && "execute" in result) {
+              return wrapBuilder(result);
+            }
+            return result;
+          };
+        }
+        return value;
+      }
+    });
+  };
+  return wrapBuilder(builder);
+}
+function patchDbWithSelectAliased(db) {
+  db.selectAliased = function(fields) {
+    return createAliasedSelectBuilder(db, fields, (selections) => db.select(selections));
+  };
+  db.selectAliasedDistinct = function(fields) {
+    return createAliasedSelectBuilder(db, fields, (selections) => db.selectDistinct(selections));
+  };
+  return db;
+}
 class ForgeSQLORMImpl {
   static instance = null;
   drizzle;
@@ -565,7 +669,7 @@ class ForgeSQLORMImpl {
       if (newOptions.logRawSqlQuery) {
         console.debug("Initializing ForgeSQLORM...");
       }
-      this.drizzle = drizzle(forgeDriver, { logger: newOptions.logRawSqlQuery });
+      this.drizzle = patchDbWithSelectAliased(drizzle(forgeDriver, { logger: newOptions.logRawSqlQuery }));
       this.crudOperations = new ForgeSQLCrudOperations(this, newOptions);
       this.fetchOperations = new ForgeSQLSelectOperations(newOptions);
     } catch (error) {
@@ -630,7 +734,7 @@ class ForgeSQLORMImpl {
     if (!fields) {
       throw new Error("fields is empty");
     }
-    return this.drizzle.select(mapSelectFieldsWithAlias(fields));
+    return this.drizzle.selectAliased(fields);
   }
   /**
    * Creates a distinct select query with unique field aliases to prevent field name collisions in joins.
@@ -652,7 +756,7 @@ class ForgeSQLORMImpl {
     if (!fields) {
       throw new Error("fields is empty");
     }
-    return this.drizzle.selectDistinct(mapSelectFieldsWithAlias(fields));
+    return this.drizzle.selectAliasedDistinct(fields);
   }
 }
 class ForgeSQLORM {
@@ -677,7 +781,7 @@ class ForgeSQLORM {
    * ```
    */
   select(fields) {
-    return this.ormInstance.getDrizzleQueryBuilder().select(mapSelectFieldsWithAlias(fields));
+    return this.ormInstance.select(fields);
   }
   /**
    * Creates a distinct select query with unique field aliases to prevent field name collisions in joins.
@@ -696,7 +800,7 @@ class ForgeSQLORM {
    * ```
    */
   selectDistinct(fields) {
-    return this.ormInstance.getDrizzleQueryBuilder().selectDistinct(mapSelectFieldsWithAlias(fields));
+    return this.ormInstance.selectDistinct(fields);
   }
   /**
    * Proxies the `crud` method from `ForgeSQLORMImpl`.
@@ -792,8 +896,8 @@ const applySchemaMigrations = async (migration) => {
   console.log("Provisioning the database");
   await sql$1._provision();
   console.info("Running schema migrations");
-  const migrations = await migration(migrationRunner);
-  const successfulMigrations = await migrations.run();
+  const migrations2 = await migration(migrationRunner);
+  const successfulMigrations = await migrations2.run();
   console.info("Migrations applied:", successfulMigrations);
   const migrationHistory = (await migrationRunner.list()).map((y) => `${y.id}, ${y.name}, ${y.migratedAt.toUTCString()}`).join("\n");
   console.info("Migrations history:\nid, name, migrated_at\n", migrationHistory);
@@ -804,6 +908,46 @@ const applySchemaMigrations = async (migration) => {
     body: "Migrations successfully executed"
   };
 };
+const migrations = mysqlTable("__migrations", {
+  id: bigint("id", { mode: "number" }).primaryKey().autoincrement(),
+  name: varchar("name", { length: 255 }).notNull(),
+  migratedAt: timestamp("migratedAt").defaultNow().notNull()
+});
+const forgeSystemTables = [migrations];
+async function fetchSchemaWebTrigger() {
+  try {
+    const tables = await getTables();
+    const createTableStatements = await generateCreateTableStatements(tables);
+    const sqlStatements = wrapWithForeignKeyChecks(createTableStatements);
+    return getHttpResponse(200, sqlStatements.join(";\n"));
+  } catch (error) {
+    console.error(JSON.stringify(error));
+    const errorMessage = error instanceof Error ? error.message : "Unknown error occurred";
+    return getHttpResponse(500, errorMessage);
+  }
+}
+async function getTables() {
+  const tables = await sql$1.executeDDL("SHOW TABLES");
+  return tables.rows.flatMap((tableInfo) => Object.values(tableInfo));
+}
+async function generateCreateTableStatements(tables) {
+  const statements = [];
+  for (const table of tables) {
+    const createTableResult = await sql$1.executeDDL(`SHOW CREATE TABLE ${table}`);
+    const createTableStatements = createTableResult.rows.filter((row) => !isSystemTable(row.Table)).map((row) => formatCreateTableStatement(row["Create Table"]));
+    statements.push(...createTableStatements);
+  }
+  return statements;
+}
+function isSystemTable(tableName) {
+  return forgeSystemTables.some((st) => getTableName(st) === tableName);
+}
+function formatCreateTableStatement(statement) {
+  return statement.replace(/"/g, "").replace("CREATE TABLE", "CREATE TABLE IF NOT EXISTS");
+}
+function wrapWithForeignKeyChecks(statements) {
+  return ["SET foreign_key_checks = 0", ...statements, "SET foreign_key_checks = 1"];
+}
 const getHttpResponse = (statusCode, body) => {
   let statusText = "";
   if (statusCode === 200) {
@@ -821,10 +965,12 @@ const getHttpResponse = (statusCode, body) => {
 export {
   ForgeSQLCrudOperations,
   ForgeSQLSelectOperations,
+  applyFromDriverTransform,
   applySchemaMigrations,
   ForgeSQLORM as default,
   dropSchemaMigrations,
   extractAlias,
+  fetchSchemaWebTrigger,
   forgeDateString,
   forgeDateTimeString,
   forgeDriver,
@@ -836,7 +982,7 @@ export {
   getTableMetadata,
   mapSelectAllFieldsToAlias,
   mapSelectFieldsWithAlias,
-  mapSelectTableToAlias,
-  parseDateTime
+  parseDateTime,
+  patchDbWithSelectAliased
 };
 //# sourceMappingURL=ForgeSQLORM.mjs.map