rake-db 2.8.19 → 2.8.21

package/dist/index.d.ts

@@ -282,6 +282,7 @@ type RakeDbConfig<CT extends ColumnTypesBase = DefaultColumnTypes> = {
     basePath: string;
     dbScript: string;
     migrationsPath: string;
+    recurrentPath: string;
     migrationsTable: string;
     snakeCase: boolean;
     commands: Record<string, (options: AdapterOptions[], config: RakeDbConfig<CT>, args: string[]) => Promise<void>>;
@@ -313,7 +314,7 @@ type AppCodeUpdater = {
 };
 
 declare const createDb: <CT extends Record<string, orchid_core.AnyColumnTypeCreator>>(arg: MaybeArray<AdapterOptions>, config: RakeDbConfig<CT>) => Promise<void>;
-declare const dropDb: (arg: MaybeArray<AdapterOptions>) => Promise<void>;
+declare const dropDb: <CT extends Record<string, orchid_core.AnyColumnTypeCreator>>(arg: MaybeArray<AdapterOptions>, config: RakeDbConfig<CT>) => Promise<void>;
 declare const resetDb: <CT extends Record<string, orchid_core.AnyColumnTypeCreator>>(arg: MaybeArray<AdapterOptions>, config: RakeDbConfig<CT>) => Promise<void>;
 
 declare const writeMigrationFile: <CT extends Record<string, orchid_core.AnyColumnTypeCreator>>(config: RakeDbConfig<CT>, version: string, name: string, content: (importPath: string, name: string) => string) => Promise<void>;

package/dist/index.js

@@ -66,6 +66,8 @@ const migrationConfigDefaults = {
 const processRakeDbConfig = (config) => {
   var _a;
   const result = __spreadValues$6(__spreadValues$6({}, migrationConfigDefaults), config);
+  if (!result.recurrentPath)
+    result.recurrentPath = path.join(result.migrationsPath, "recurrent");
   if (config.appCodeUpdater && (!("baseTable" in config) || !config.baseTable)) {
     throw new Error(
       "`baseTable` option is required in `rakeDb` for `appCodeUpdater`"
@@ -90,6 +92,9 @@ const processRakeDbConfig = (config) => {
       result.migrationsPath
     );
   }
+  if (!path.isAbsolute(result.recurrentPath)) {
+    result.recurrentPath = path.resolve(result.basePath, result.recurrentPath);
+  }
   if ("baseTable" in config) {
     const proto = (_a = config.baseTable) == null ? void 0 : _a.prototype;
     result.columnTypes = proto.columnTypes || pqb.columnTypes;
@@ -214,23 +219,25 @@ const getMigrationFiles = async (config, up) => {
     return [];
   }
   const sort = up ? sortAsc : sortDesc;
-  return sort(files).map((file) => {
-    if (!file.endsWith(".ts")) {
-      throw new Error(
-        `Only .ts files are supported for migration, received: ${file}`
-      );
-    }
-    const timestampMatch = file.match(/^(\d{14})\D/);
-    if (!timestampMatch) {
-      throw new Error(
-        `Migration file name should start with 14 digit version, received ${file}`
-      );
+  return sort(files.filter((file) => path.basename(file).includes("."))).map(
+    (file) => {
+      if (!file.endsWith(".ts")) {
+        throw new Error(
+          `Only .ts files are supported for migration, received: ${file}`
+        );
+      }
+      const timestampMatch = file.match(/^(\d{14})\D/);
+      if (!timestampMatch) {
+        throw new Error(
+          `Migration file name should start with 14 digit version, received ${file}`
+        );
+      }
+      return {
+        path: path.resolve(migrationsPath, file),
+        version: timestampMatch[1]
+      };
     }
-    return {
-      path: path.resolve(migrationsPath, file),
-      version: timestampMatch[1]
-    };
-  });
+  );
 };
 const sortAsc = (arr) => arr.sort();
 const sortDesc = (arr) => arr.sort((a, b) => a > b ? -1 : 1);
@@ -1846,9 +1853,9 @@ const createDb = async (arg, config) => {
     });
   }
 };
-const dropDb = async (arg) => {
+const dropDb = async (arg, config) => {
   for (const options of orchidCore.toArray(arg)) {
-    await createOrDrop(options, options, migrationConfigDefaults, {
+    await createOrDrop(options, options, config, {
       sql({ database }) {
         return `DROP DATABASE "${database}"`;
       },
@@ -1862,7 +1869,7 @@ const dropDb = async (arg) => {
   }
 };
 const resetDb = async (arg, config) => {
-  await dropDb(arg);
+  await dropDb(arg, config);
   await createDb(arg, config);
   await migrate(arg, config);
 };
@@ -3058,6 +3065,52 @@ Append \`as\` method manually to ${count > 1 ? "these" : "this"} column${count >
   adapter.close();
 };
 
+const runRecurrentMigrations = async (options, config) => {
+  var _a;
+  let dbs;
+  let files = 0;
+  await readdirRecursive(config.recurrentPath, async (path) => {
+    files++;
+    dbs != null ? dbs : dbs = orchidCore.toArray(options).map(
+      (opts) => pqb.createDb({ adapter: new pqb.Adapter(opts) })
+    );
+    const sql = await promises.readFile(path, "utf-8");
+    await Promise.all(
+      dbs.map(async (db) => {
+        await db.adapter.arrays(sql);
+      })
+    );
+  });
+  if (dbs) {
+    await Promise.all(dbs.map((db) => db.close()));
+    if (files > 0) {
+      (_a = config.logger) == null ? void 0 : _a.log(
+        `Applied ${files} recurrent migration file${files > 1 ? "s" : ""}`
+      );
+    }
+  }
+};
+const readdirRecursive = async (dirPath, cb) => {
+  const list = await promises.readdir(dirPath).catch((err) => {
+    if (err.code !== "ENOENT")
+      throw err;
+    return;
+  });
+  if (!list)
+    return;
+  await Promise.all(
+    list.map(async (item) => {
+      const path$1 = path.join(dirPath, item);
+      const info = await promises.stat(path$1);
+      if (info.isDirectory()) {
+        await readdirRecursive(path$1, cb);
+      } else if (info.isFile() && path$1.endsWith(".sql")) {
+        await cb(path$1);
+      }
+    })
+  );
+};
+
 const rakeDb = (options, partialConfig = {}, args = process.argv.slice(2)) => {
   const config = processRakeDbConfig(partialConfig);
   const promise = runCommand(options, config, args);
@@ -3072,29 +3125,32 @@ const rakeDb = (options, partialConfig = {}, args = process.argv.slice(2)) => {
 };
 const runCommand = async (options, config, args = process.argv.slice(2)) => {
   var _a, _b, _c;
-  const command = (_a = args[0]) == null ? void 0 : _a.split(":")[0];
+  const arg = (_a = args[0]) == null ? void 0 : _a.split(":")[0];
   try {
-    if (command === "create") {
+    if (arg === "create") {
       await createDb(options, config);
-    } else if (command === "drop") {
-      await dropDb(options);
-    } else if (command === "reset") {
+    } else if (arg === "drop") {
+      await dropDb(options, config);
+    } else if (arg === "reset") {
       await resetDb(options, config);
-    } else if (command === "migrate") {
+    } else if (arg === "up" || arg === "migrate") {
       await migrate(options, config, args.slice(1));
-    } else if (command === "rollback") {
+    } else if (arg === "down" || arg === "rollback") {
       await rollback(options, config, args.slice(1));
-    } else if (command === "redo") {
+    } else if (arg === "redo") {
       await redo(options, config, args.slice(1));
-    } else if (command === "new") {
+    } else if (arg === "new") {
       await generate(config, args.slice(1));
-    } else if (command === "pull") {
+    } else if (arg === "pull") {
       await pullDbStructure(orchidCore.toArray(options)[0], config);
-    } else if (config.commands[command]) {
-      await config.commands[command](orchidCore.toArray(options), config, args.slice(1));
-    } else {
+    } else if (config.commands[arg]) {
+      await config.commands[arg](orchidCore.toArray(options), config, args.slice(1));
+    } else if (arg !== "rec" && arg !== "recurrent") {
       (_b = config.logger) == null ? void 0 : _b.log(help);
     }
+    if (arg === "migrate" || arg === "rec" || arg === "recurrent" || arg === "redo") {
+      await runRecurrentMigrations(options, config);
+    }
   } catch (err) {
     if (err instanceof RakeDbError) {
       (_c = config.logger) == null ? void 0 : _c.error(err.message);
@@ -3113,9 +3169,11 @@ Commands:
   drop                    drop databases
   reset                   drop, create and migrate databases
   new                     create new migration file, see below
-  migrate                 migrate pending migrations
-  rollback                rollback the last migrated
-  redo                    rollback and migrate
+  migrate                 migrate pending migrations, run recurrent
+  up                      migrate pending migrations, don't run recurrent
+  rollback or down        rollback the last migrated
+  redo                    rollback and migrate, run recurrent
+  rec or recurrent        run recurrent migrations
   no or unknown command   prints this message
   
 Migrate arguments: