rake-db 2.4.44 → 2.6.0

package/dist/index.d.ts

@@ -287,7 +287,7 @@ declare const dropDb: (arg: MaybeArray<AdapterOptions>) => Promise<void>;
 declare const resetDb: (arg: MaybeArray<AdapterOptions>, config: RakeDbConfig) => Promise<void>;
 
 declare const writeMigrationFile: (config: RakeDbConfig, version: string, name: string, content: string) => Promise<void>;
-declare const generate: (config: RakeDbConfig, args: string[]) => Promise<void>;
+declare const generate: (config: RakeDbConfig, [name]: string[]) => Promise<void>;
 declare const makeFileTimeStamp: () => string;
 
 type ChangeCallback = (db: Migration, up: boolean) => Promise<void>;

package/dist/index.js

@@ -1683,9 +1683,13 @@ const migrateOrRollback = async (options, config, args, up) => {
   }
 };
 const changeCache = {};
+const begin = {
+  text: "BEGIN",
+  values: orchidCore.emptyArray
+};
 const processMigration = async (db, up, file, config, options, appCodeUpdaterCache) => {
   var _a;
-  const asts = await db.transaction(async (tx) => {
+  const asts = await db.transaction(begin, async (tx) => {
     const db2 = createMigrationInterface(tx, up, config);
     clearChanges();
     let changes = changeCache[file.path];
@@ -1849,17 +1853,11 @@ const writeMigrationFile = async (config, version, name, content) => {
   await promises.writeFile(filePath, content);
   (_a = config.logger) == null ? void 0 : _a.log(`Created ${orchidCore.pathToLog(filePath)}`);
 };
-const generate = async (config, args) => {
-  const name = args[0];
+const generate = async (config, [name]) => {
   if (!name)
     throw new Error("Migration name is missing");
   const version = makeFileTimeStamp();
-  await writeMigrationFile(
-    config,
-    version,
-    name,
-    makeContent(name, args.slice(1))
-  );
+  await writeMigrationFile(config, version, name, makeContent(name));
 };
 const makeFileTimeStamp = () => {
   const now = /* @__PURE__ */ new Date();
@@ -1872,7 +1870,7 @@ const makeFileTimeStamp = () => {
     now.getUTCSeconds()
   ].map((value) => value < 10 ? `0${value}` : value).join("");
 };
-const makeContent = (name, args) => {
+const makeContent = (name) => {
   let content = `import { change } from 'rake-db';
 
 change(async (db) => {`;
@@ -1880,42 +1878,27 @@ change(async (db) => {`;
   if (rest) {
     if (first === "create" || first === "drop") {
       content += `
-  await db.${first === "create" ? "createTable" : "dropTable"}('${rest}', (t) => ({`;
-      content += makeColumnsContent(args);
-      content += "\n  }));";
+  await db.${first === "create" ? "createTable" : "dropTable"}('${rest}', (t) => ({
+    
+  }));`;
     } else if (first === "change") {
       content += `
-  await db.changeTable('${rest}', (t) => ({`;
-      content += "\n  }));";
+  await db.changeTable('${rest}', (t) => ({
+    
+  }));`;
     } else if (first === "add" || first === "remove") {
       const table = first === "add" ? getTextAfterTo(rest) : getTextAfterFrom(rest);
       content += `
-  await db.changeTable(${table ? `'${table}'` : "tableName"}, (t) => ({`;
-      content += makeColumnsContent(args, first);
-      content += "\n  }));";
+  await db.changeTable(${table ? `'${table}'` : "tableName"}, (t) => ({
+    
+  }));`;
     }
   }
   return content + "\n});\n";
 };
-const makeColumnsContent = (args, method) => {
-  let content = "";
-  const prepend = method ? `t.${method}(` : "";
-  const append = method ? ")" : "";
-  for (const arg of args) {
-    const [name, def] = arg.split(":");
-    if (!def) {
-      throw new Error(
-        `Column argument should be similar to name:type, name:type.method1.method2, name:type(arg).method(arg). Example: name:varchar(20).nullable. Received: ${arg}`
-      );
-    }
-    const methods = def.split(".").map((method2) => method2.endsWith(")") ? `.${method2}` : `.${method2}()`);
-    content += `
-    ${name}: ${prepend}t${methods.join("")}${append},`;
-  }
-  return content;
-};
 
 const filterSchema = (table) => `${table} !~ '^pg_' AND ${table} != 'information_schema'`;
+const jsonAgg = (sql2, as) => `(SELECT coalesce(json_agg(t.*), '[]') FROM (${sql2}) t) AS "${as}"`;
 const columnsSql = ({
   schema,
   table,
@@ -1997,50 +1980,33 @@ WHERE a.attnum > 0
   AND NOT a.attisdropped
   AND ${where}
 ORDER BY a.attnum`;
-class DbStructure {
-  constructor(db) {
-    this.db = db;
-  }
-  async getSchemas() {
-    const { rows } = await this.db.arrays(
-      `SELECT n.nspname "name"
+const schemasSql = `SELECT coalesce(json_agg(nspname ORDER BY nspname), '[]')
 FROM pg_catalog.pg_namespace n
-WHERE ${filterSchema("n.nspname")}
-ORDER BY "name"`
-    );
-    return rows.flat();
-  }
-  async getTables() {
-    const { rows } = await this.db.query(
-      `SELECT
+WHERE ${filterSchema("nspname")}`;
+const tablesSql = `SELECT
   nspname AS "schemaName",
   relname AS "name",
   obj_description(c.oid) AS comment,
   (SELECT coalesce(json_agg(t), '[]') FROM (${columnsSql({
-        schema: "n",
-        table: "c",
-        where: "a.attrelid = c.oid"
-      })}) t) AS "columns"
+  schema: "n",
+  table: "c",
+  where: "a.attrelid = c.oid"
+})}) t) AS "columns"
 FROM pg_class c
 JOIN pg_catalog.pg_namespace n ON n.oid = relnamespace
 WHERE relkind = 'r'
   AND ${filterSchema("nspname")}
-ORDER BY relname`
-    );
-    return rows;
-  }
-  async getViews() {
-    const { rows } = await this.db.query(
-      `SELECT
+ORDER BY relname`;
+const viewsSql = `SELECT
   nc.nspname AS "schemaName",
   c.relname AS "name",
   right(substring(r.ev_action from ':hasRecursive w'), 1)::bool AS "isRecursive",
   array_to_json(c.reloptions) AS "with",
   (SELECT coalesce(json_agg(t), '[]') FROM (${columnsSql({
-        schema: "nc",
-        table: "c",
-        where: "a.attrelid = c.oid"
-      })}) t) AS "columns",
+  schema: "nc",
+  table: "c",
+  where: "a.attrelid = c.oid"
+})}) t) AS "columns",
   pg_get_viewdef(c.oid) AS "sql"
 FROM pg_namespace nc
 JOIN pg_class c
@@ -2049,38 +2015,20 @@ JOIN pg_class c
  AND c.relpersistence != 't'
 JOIN pg_rewrite r ON r.ev_class = c.oid
 WHERE ${filterSchema("nc.nspname")}
-ORDER BY c.relname`
-    );
-    return rows;
+ORDER BY c.relname`;
+const sql = `SELECT (${schemasSql}) AS "schemas", ${jsonAgg(
+  tablesSql,
+  "tables"
+)}, ${jsonAgg(viewsSql, "views")}`;
+class DbStructure {
+  constructor(db) {
+    this.db = db;
   }
-  async getProcedures() {
-    const { rows } = await this.db.query(
-      `SELECT
-  n.nspname AS "schemaName",
-  proname AS name,
-  proretset AS "returnSet",
-  (
-    SELECT typname FROM pg_type WHERE oid = prorettype
-  ) AS "returnType",
-  prokind AS "kind",
-  coalesce((
-    SELECT true FROM information_schema.triggers
-    WHERE n.nspname = trigger_schema AND trigger_name = proname
-    LIMIT 1
-  ), false) AS "isTrigger",
-  coalesce((
-    SELECT json_agg(pg_type.typname)
-    FROM unnest(coalesce(proallargtypes, proargtypes)) typeId
-    JOIN pg_type ON pg_type.oid = typeId
-  ), '[]') AS "types",
-  coalesce(to_json(proallargtypes::int[]), to_json(proargtypes::int[])) AS "argTypes",
-  coalesce(to_json(proargmodes), '[]') AS "argModes",
-  to_json(proargnames) AS "argNames"
-FROM pg_proc p
-JOIN pg_namespace n ON p.pronamespace = n.oid
-WHERE ${filterSchema("n.nspname")}`
-    );
-    return rows;
+  async getStructure() {
+    const {
+      rows: [structure]
+    } = await this.db.query(sql);
+    return structure;
   }
   async getIndexes() {
     const { rows } = await this.db.query(
@@ -2490,18 +2438,14 @@ const structureToAst = async (ctx, db) => {
 };
 const getData = async (db) => {
   const [
-    schemas,
-    tables,
-    views,
+    { schemas, tables, views },
     constraints,
     indexes,
     extensions,
     enums,
     domains
   ] = await Promise.all([
-    db.getSchemas(),
-    db.getTables(),
-    db.getViews(),
+    db.getStructure(),
     db.getConstraints(),
     db.getIndexes(),
     db.getExtensions(),
@@ -3102,6 +3046,9 @@ const rakeDb = async (options, partialConfig = {}, args = process.argv.slice(2))
 };
 const help = `Usage: rake-db [command] [arguments]
 
+See documentation at:
+https://orchid-orm.netlify.app/guide/migration-commands.html
+
 Commands:
   create                  create databases
   drop                    drop databases
@@ -3124,17 +3071,6 @@ Rollback arguments:
 Migrate and rollback common arguments:
   --code                  run code updater, overrides \`useCodeUpdater\` option
   --code false            do not run code updater
-  
-New migration file arguments:
-- (required) first argument is migration name
-  * create*               template for create table
-  * change*               template for change table
-  * add*To*               template for add columns
-  * remove*From*          template for remove columns
-  * drop*                 template for drop table
-
-- other arguments considered as columns with types and optional methods:
-  rake-db new createTable id:serial.primaryKey name:text.nullable
 `;
 
 exports.MigrationBase = MigrationBase;