rake-db 1.3.2 → 2.0.0

package/src/common.test.ts

@@ -0,0 +1,281 @@
+import {
+  createSchemaMigrations,
+  getDatabaseAndUserFromOptions,
+  getFirstWordAndRest,
+  getMigrationConfigWithDefaults,
+  getMigrationFiles,
+  getTextAfterTo,
+  joinColumns,
+  joinWords,
+  migrationConfigDefaults,
+  setAdapterOptions,
+  setAdminCredentialsToOptions,
+  sortAsc,
+  sortDesc,
+} from './common';
+import Enquirer from 'enquirer';
+import { Adapter } from 'pqb';
+import { readdir } from 'fs/promises';
+import path from 'path';
+
+jest.mock('enquirer', () => {
+  class Snippet {
+    constructor(public params: Record<string, unknown>) {}
+    run() {}
+  }
+  Snippet.prototype.run = jest.fn();
+
+  return {
+    Snippet,
+  };
+});
+
+jest.mock('fs/promises', () => ({
+  readdir: jest.fn(),
+}));
+
+describe('common', () => {
+  describe('getMigrationConfigWithDefaults', () => {
+    it('should return config with defaults', () => {
+      const result = getMigrationConfigWithDefaults({
+        migrationsPath: 'custom-path',
+      });
+
+      expect(result).toEqual({
+        migrationsPath: 'custom-path',
+        migrationsTable: 'schemaMigrations',
+        requireTs: expect.any(Function),
+      });
+    });
+  });
+
+  describe('getDatabaseAndUserFromOptions', () => {
+    it('should return data from connectionString', () => {
+      const result = getDatabaseAndUserFromOptions({
+        connectionString: 'postgres://user:password@localhost:5432/dbname',
+      });
+
+      expect(result).toEqual({
+        database: 'dbname',
+        user: 'user',
+      });
+    });
+
+    it('should return data from options when no connectionString', () => {
+      const result = getDatabaseAndUserFromOptions({
+        database: 'dbname',
+        user: 'user',
+      });
+
+      expect(result).toEqual({
+        database: 'dbname',
+        user: 'user',
+      });
+    });
+  });
+
+  describe('setAdapterOptions', () => {
+    it('should set options in connectionString to postgres', () => {
+      const result = setAdapterOptions(
+        {
+          connectionString: 'postgres://user:password@localhost:5432/dbname',
+        },
+        {
+          database: 'updated-db',
+          user: 'updated-user',
+          password: 'updated-password',
+        },
+      );
+
+      expect(result).toEqual({
+        connectionString:
+          'postgres://updated-user:updated-password@localhost:5432/updated-db',
+      });
+    });
+
+    it('should set object options', () => {
+      const result = setAdapterOptions(
+        {
+          database: 'dbname',
+          user: 'user',
+          password: 'password',
+        },
+        {
+          database: 'updated-db',
+          user: 'updated-user',
+          password: 'updated-password',
+        },
+      );
+
+      expect(result).toEqual({
+        database: 'updated-db',
+        user: 'updated-user',
+        password: 'updated-password',
+      });
+    });
+  });
+
+  describe('setAdminCredentialsToOptions', () => {
+    beforeEach(() => {
+      (Enquirer as any).Snippet.prototype.run.mockReturnValueOnce({
+        values: {
+          user: 'admin-user',
+          password: 'admin-password',
+        },
+      });
+    });
+
+    it('should set admin credentials to connectionString', async () => {
+      const result = await setAdminCredentialsToOptions({
+        connectionString: 'postgres://user:password@localhost:5432/dbname',
+      });
+
+      expect(result).toEqual({
+        connectionString:
+          'postgres://admin-user:admin-password@localhost:5432/dbname',
+      });
+    });
+
+    it('should set admin credentials to options', async () => {
+      const result = await setAdminCredentialsToOptions({
+        database: 'dbname',
+        user: 'user',
+        password: 'password',
+      });
+
+      expect(result).toEqual({
+        database: 'dbname',
+        user: 'admin-user',
+        password: 'admin-password',
+      });
+    });
+  });
+
+  describe('createSchemaMigrations', () => {
+    const log = console.log;
+    const mockedLog = jest.fn();
+    const mockedQuery = jest.fn();
+
+    const db = new Adapter({ connectionString: 'test' });
+    db.query = mockedQuery;
+
+    beforeAll(() => {
+      console.log = mockedLog;
+    });
+    beforeEach(() => {
+      jest.clearAllMocks();
+    });
+    afterAll(() => {
+      console.log = log;
+    });
+
+    it('should create a "schemaMigrations" table', async () => {
+      mockedQuery.mockReturnValueOnce(undefined);
+
+      await createSchemaMigrations(db, migrationConfigDefaults);
+
+      expect(mockedQuery.mock.calls).toEqual([
+        [`CREATE TABLE "schemaMigrations" ( version TEXT NOT NULL )`],
+      ]);
+
+      expect(mockedLog.mock.calls).toEqual([['Created versions table']]);
+    });
+
+    it('should inform if table already exists', async () => {
+      mockedQuery.mockRejectedValue({ code: '42P07' });
+
+      await createSchemaMigrations(db, migrationConfigDefaults);
+
+      expect(mockedQuery.mock.calls).toEqual([
+        [`CREATE TABLE "schemaMigrations" ( version TEXT NOT NULL )`],
+      ]);
+
+      expect(mockedLog.mock.calls).toEqual([['Versions table exists']]);
+    });
+  });
+
+  describe('getFirstWordAndRest', () => {
+    it('should return pair of first word and rest', () => {
+      expect(getFirstWordAndRest('fooBarBaz')).toEqual(['foo', 'barBaz']);
+      expect(getFirstWordAndRest('foo-barBaz')).toEqual(['foo', 'barBaz']);
+      expect(getFirstWordAndRest('foo_barBaz')).toEqual(['foo', 'barBaz']);
+    });
+
+    it('should return input when it is a single word', () => {
+      expect(getFirstWordAndRest('foo')).toEqual(['foo']);
+    });
+  });
+
+  describe('getTextAfterTo', () => {
+    it('should return text after To or to', () => {
+      expect(getTextAfterTo('addColumnToTable')).toBe('table');
+      expect(getTextAfterTo('add-column-to-table')).toBe('table');
+      expect(getTextAfterTo('add_column_to_table')).toBe('table');
+    });
+  });
+
+  describe('getMigrationFiles', () => {
+    it('should return files with versions', async () => {
+      const version = '12345678901234';
+      const files = [`${version}_a.ts`, `${version}_b.ts`, `${version}_c.ts`];
+      (readdir as jest.Mock).mockReturnValueOnce(files);
+
+      const result = await getMigrationFiles(migrationConfigDefaults, true);
+      expect(result).toEqual(
+        files.map((file) => ({
+          path: path.join(migrationConfigDefaults.migrationsPath, file),
+          version,
+        })),
+      );
+    });
+
+    it('should return empty array on error', async () => {
+      (readdir as jest.Mock).mockRejectedValue(new Error());
+
+      const result = await getMigrationFiles(migrationConfigDefaults, true);
+      expect(result).toEqual([]);
+    });
+
+    it('should throw if file is not a .ts file', async () => {
+      (readdir as jest.Mock).mockReturnValueOnce(['file.js']);
+
+      await expect(
+        getMigrationFiles(migrationConfigDefaults, true),
+      ).rejects.toThrow('Only .ts files are supported');
+    });
+
+    it('should throw on improper version', async () => {
+      (readdir as jest.Mock).mockReturnValueOnce(['1234567890_file.ts']);
+
+      await expect(
+        getMigrationFiles(migrationConfigDefaults, true),
+      ).rejects.toThrow(
+        'Migration file name should start with 14 digit version',
+      );
+    });
+  });
+
+  describe('sortAsc', () => {
+    it('should sort ascending', () => {
+      expect(sortAsc(['a', 'c', 'b'])).toEqual(['a', 'b', 'c']);
+    });
+  });
+
+  describe('sortDesc', () => {
+    it('should sort descending', () => {
+      expect(sortDesc(['a', 'c', 'b'])).toEqual(['c', 'b', 'a']);
+    });
+  });
+
+  describe('joinWords', () => {
+    it('should join words', () => {
+      expect(joinWords('foo', 'bar', 'baz')).toEqual('fooBarBaz');
+    });
+  });
+
+  describe('joinColumns', () => {
+    it('should join columns', () => {
+      expect(joinColumns(['a', 'b', 'c'])).toBe('"a", "b", "c"');
+    });
+  });
+});

package/src/common.ts

@@ -0,0 +1,224 @@
+import { Adapter, AdapterOptions } from 'pqb';
+import Enquirer from 'enquirer';
+import path from 'path';
+import { readdir } from 'fs/promises';
+
+export type MigrationConfig = {
+  migrationsPath: string;
+  migrationsTable: string;
+  requireTs(path: string): void;
+};
+
+const registered = false;
+
+export const migrationConfigDefaults = {
+  migrationsPath: path.resolve(process.cwd(), 'src', 'migrations'),
+  migrationsTable: 'schemaMigrations',
+  requireTs(path: string) {
+    if (!registered) {
+      // eslint-disable-next-line @typescript-eslint/no-var-requires
+      require('ts-node').register({ compilerOptions: { module: 'CommonJS' } });
+    }
+    require(path);
+  },
+};
+
+export const getMigrationConfigWithDefaults = (
+  config: Partial<MigrationConfig>,
+) => {
+  return { ...migrationConfigDefaults, ...config };
+};
+
+export const getDatabaseAndUserFromOptions = (
+  options: AdapterOptions,
+): { database: string; user: string } => {
+  if (options.connectionString) {
+    const url = new URL(options.connectionString);
+    return {
+      database: url.pathname.slice(1),
+      user: url.username,
+    };
+  } else {
+    return {
+      database: options.database as string,
+      user: options.user as string,
+    };
+  }
+};
+
+export const setAdapterOptions = (
+  options: AdapterOptions,
+  set: { database?: string; user?: string; password?: string },
+): AdapterOptions => {
+  if (options.connectionString) {
+    const url = new URL(options.connectionString);
+
+    if ('database' in set) {
+      url.pathname = `/${set.database}`;
+    }
+
+    if (set.user !== undefined) {
+      url.username = set.user;
+    }
+
+    if (set.password !== undefined) {
+      url.password = set.password;
+    }
+
+    return { ...options, connectionString: url.toString() };
+  } else {
+    return {
+      ...options,
+      ...set,
+    };
+  }
+};
+
+const askAdminCredentials = async (): Promise<{
+  user: string;
+  password: string;
+}> => {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  const prompt = new (Enquirer as any).Snippet({
+    message: `What are postgres admin login and password?`,
+    fields: [
+      {
+        name: 'user',
+        required: true,
+      },
+      {
+        name: 'password',
+      },
+    ],
+    values: {
+      user: 'postgres',
+      password: '',
+    },
+    template: 'Admin user: {{user}}\nAdmin password: {{password}}',
+  });
+
+  const { values } = await prompt.run();
+  if (!values.password) values.password = '';
+
+  return values;
+};
+
+export const setAdminCredentialsToOptions = async (
+  options: AdapterOptions,
+): Promise<AdapterOptions> => {
+  const values = await askAdminCredentials();
+  return setAdapterOptions(options, values);
+};
+
+export const createSchemaMigrations = async (
+  db: Adapter,
+  config: MigrationConfig,
+) => {
+  try {
+    await db.query(
+      `CREATE TABLE "${config.migrationsTable}" ( version TEXT NOT NULL )`,
+    );
+    console.log('Created versions table');
+  } catch (err) {
+    if ((err as Record<string, unknown>).code === '42P07') {
+      console.log('Versions table exists');
+    } else {
+      throw err;
+    }
+  }
+};
+
+export const getFirstWordAndRest = (
+  input: string,
+): [string] | [string, string] => {
+  const index = input.search(/(?=[A-Z])|[-_]/);
+  if (index !== -1) {
+    const restStart =
+      input[index] === '-' || input[index] === '_' ? index + 1 : index;
+    const rest = input.slice(restStart);
+    return [input.slice(0, index), rest[0].toLowerCase() + rest.slice(1)];
+  } else {
+    return [input];
+  }
+};
+
+const getTextAfterRegExp = (
+  input: string,
+  regex: RegExp,
+  length: number,
+): string | undefined => {
+  let index = input.search(regex);
+  if (index === -1) return;
+
+  if (input[index] === '-' || input[index] === '_') index++;
+  index += length;
+
+  const start = input[index] == '-' || input[index] === '_' ? index + 1 : index;
+  const text = input.slice(start);
+  return text[0].toLowerCase() + text.slice(1);
+};
+
+export const getTextAfterTo = (input: string): string | undefined => {
+  return getTextAfterRegExp(input, /(To|-to|_to)[A-Z-_]/, 2);
+};
+
+export const getTextAfterFrom = (input: string): string | undefined => {
+  return getTextAfterRegExp(input, /(From|-from|_from)[A-Z-_]/, 4);
+};
+
+export type MigrationFile = {
+  path: string;
+  version: string;
+};
+
+export const getMigrationFiles = async (
+  config: MigrationConfig,
+  up: boolean,
+): Promise<MigrationFile[]> => {
+  const { migrationsPath } = config;
+
+  let files: string[];
+  try {
+    files = await readdir(migrationsPath);
+  } catch (_) {
+    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 {
+      path: path.join(migrationsPath, file),
+      version: timestampMatch[1],
+    };
+  });
+};
+
+export const sortAsc = (arr: string[]) => arr.sort();
+
+export const sortDesc = (arr: string[]) => arr.sort((a, b) => (a > b ? -1 : 1));
+
+export const joinWords = (...words: string[]) => {
+  return words
+    .slice(1)
+    .reduce(
+      (acc, word) => acc + word[0].toUpperCase() + word.slice(1),
+      words[0],
+    );
+};
+
+export const joinColumns = (columns: string[]) => {
+  return columns.map((column) => `"${column}"`).join(', ');
+};

package/src/index.ts

@@ -0,0 +1,2 @@
+export * from './commands/createOrDrop';
+export { change } from './migration/change';

package/src/migration/change.ts

@@ -0,0 +1,20 @@
+import { Migration } from './migration';
+
+let currentMigration: Migration | undefined;
+let currentPromise: Promise<void> | undefined;
+let currentUp = true;
+
+export const change = (fn: (db: Migration, up: boolean) => Promise<void>) => {
+  if (!currentMigration) throw new Error('Database instance is not set');
+  currentPromise = fn(currentMigration, currentUp);
+};
+
+export const setCurrentMigration = (db: Migration) => {
+  currentMigration = db;
+};
+
+export const setCurrentMigrationUp = (up: boolean) => {
+  currentUp = up;
+};
+
+export const getCurrentPromise = () => currentPromise;