rake-db 2.3.29 → 2.3.31

package/src/common.test.ts

@@ -1,295 +0,0 @@
-import {
-  createSchemaMigrations,
-  getDatabaseAndUserFromOptions,
-  getFirstWordAndRest,
-  processRakeDbConfig,
-  getMigrationFiles,
-  getTextAfterTo,
-  joinColumns,
-  joinWords,
-  quoteWithSchema,
-  setAdapterOptions,
-  setAdminCredentialsToOptions,
-  sortAsc,
-  sortDesc,
-  migrationConfigDefaults,
-} from './common';
-import prompts from 'prompts';
-import { Adapter } from 'pqb';
-import { readdir } from 'fs/promises';
-import path from 'path';
-import { asMock } from './test-utils';
-
-jest.mock('prompts', () => jest.fn());
-
-jest.mock('fs/promises', () => ({
-  readdir: jest.fn(),
-}));
-
-const config = { ...migrationConfigDefaults, basePath: __dirname };
-
-describe('common', () => {
-  describe('processRakeDbConfig', () => {
-    it('should return config with defaults', () => {
-      const result = processRakeDbConfig({
-        basePath: __dirname,
-        migrationsPath: 'custom-path',
-      });
-
-      expect(result).toEqual({
-        basePath: __dirname,
-        migrationsPath: path.resolve(__dirname, 'custom-path'),
-        migrationsTable: 'schemaMigrations',
-        import: expect.any(Function),
-        log: true,
-        logger: console,
-        useCodeUpdater: true,
-        commands: {},
-      });
-    });
-  });
-
-  describe('getDatabaseAndUserFromOptions', () => {
-    it('should return data from databaseURL', () => {
-      const result = getDatabaseAndUserFromOptions({
-        databaseURL: 'postgres://user:password@localhost:5432/dbname',
-      });
-
-      expect(result).toEqual({
-        database: 'dbname',
-        user: 'user',
-      });
-    });
-
-    it('should return data from options when no databaseURL', () => {
-      const result = getDatabaseAndUserFromOptions({
-        database: 'dbname',
-        user: 'user',
-      });
-
-      expect(result).toEqual({
-        database: 'dbname',
-        user: 'user',
-      });
-    });
-  });
-
-  describe('setAdapterOptions', () => {
-    it('should set options in databaseURL to postgres', () => {
-      const result = setAdapterOptions(
-        {
-          databaseURL: 'postgres://user:password@localhost:5432/dbname',
-        },
-        {
-          database: 'updated-db',
-          user: 'updated-user',
-          password: 'updated-password',
-        },
-      );
-
-      expect(result).toEqual({
-        databaseURL:
-          '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(() => {
-      asMock(prompts).mockResolvedValueOnce({
-        confirm: true,
-      });
-
-      asMock(prompts).mockResolvedValueOnce({
-        user: 'admin-user',
-        password: 'admin-password',
-      });
-    });
-
-    it('should set admin credentials to databaseURL', async () => {
-      const result = await setAdminCredentialsToOptions({
-        databaseURL: 'postgres://user:password@localhost:5432/dbname',
-      });
-
-      expect(result).toEqual({
-        databaseURL:
-          '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({
-      databaseURL: 'postgres://user:password@host:1234/db-name',
-    });
-    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, config);
-
-      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, config);
-
-      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(config, true);
-      expect(result).toEqual(
-        files.map((file) => ({
-          path: path.resolve(config.migrationsPath, file),
-          version,
-        })),
-      );
-    });
-
-    it('should return empty array on error', async () => {
-      (readdir as jest.Mock).mockRejectedValue(new Error());
-
-      const result = await getMigrationFiles(config, 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(config, 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(config, 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"');
-    });
-  });
-
-  describe('quoteWithSchema', () => {
-    it('should quote a name', () => {
-      expect(quoteWithSchema({ name: 'table' })).toBe('"table"');
-    });
-
-    it('should quote a name with schema', () => {
-      expect(quoteWithSchema({ schema: 'schema', name: 'table' })).toBe(
-        '"schema"."table"',
-      );
-    });
-  });
-});

package/src/common.ts

@@ -1,353 +0,0 @@
-import {
-  Adapter,
-  AdapterOptions,
-  DbResult,
-  DefaultColumnTypes,
-  EnumColumn,
-  NoPrimaryKeyOption,
-  QueryLogOptions,
-  singleQuote,
-} from 'pqb';
-import path from 'path';
-import { readdir } from 'fs/promises';
-import { RakeDbAst } from './ast';
-import prompts from 'prompts';
-import { TableQuery } from './migration/createTable';
-
-type Db = DbResult<DefaultColumnTypes>;
-
-export type RakeDbConfig = {
-  basePath: string;
-  migrationsPath: string;
-  migrationsTable: string;
-  commands: Record<
-    string,
-    (
-      options: AdapterOptions[],
-      config: RakeDbConfig,
-      args: string[],
-    ) => Promise<void>
-  >;
-  import(path: string): Promise<void>;
-  noPrimaryKey?: NoPrimaryKeyOption;
-  appCodeUpdater?: AppCodeUpdater;
-  useCodeUpdater?: boolean;
-  beforeMigrate?(db: Db): Promise<void>;
-  afterMigrate?(db: Db): Promise<void>;
-  beforeRollback?(db: Db): Promise<void>;
-  afterRollback?(db: Db): Promise<void>;
-} & QueryLogOptions;
-
-export type AppCodeUpdater = (params: {
-  ast: RakeDbAst;
-  options: AdapterOptions;
-  basePath: string;
-  cache: object;
-}) => Promise<void>;
-
-export const migrationConfigDefaults: Omit<RakeDbConfig, 'basePath'> = {
-  migrationsPath: path.join('src', 'db', 'migrations'),
-  migrationsTable: 'schemaMigrations',
-  commands: {},
-  import: (path: string) => import(path),
-  log: true,
-  logger: console,
-  useCodeUpdater: true,
-};
-
-export const processRakeDbConfig = (
-  config: Partial<RakeDbConfig>,
-): RakeDbConfig => {
-  const result = { ...migrationConfigDefaults, ...config };
-
-  if (!result.basePath) {
-    let stack: NodeJS.CallSite[] | undefined;
-    Error.prepareStackTrace = (_, s) => (stack = s);
-    new Error().stack;
-    if (stack) {
-      const thisFile = stack[0]?.getFileName();
-      const thisDir = thisFile && path.dirname(thisFile);
-      for (const item of stack) {
-        let file = item.getFileName();
-        if (
-          !file ||
-          path.dirname(file) === thisDir ||
-          /\bnode_modules\b/.test(file)
-        ) {
-          continue;
-        }
-
-        // on Windows with ESM file is file:///C:/path/to/file.ts
-        // it is not a valid URL
-        if (/file:\/\/\/\w+:\//.test(file)) {
-          file = decodeURI(file.slice(8));
-        } else {
-          try {
-            file = new URL(file).pathname;
-          } catch (_) {}
-        }
-
-        result.basePath = path.dirname(file);
-        break;
-      }
-    }
-
-    if (!result.basePath) {
-      throw new Error(
-        'Failed to determine path to db script. Please set basePath option of rakeDb',
-      );
-    }
-  }
-
-  if (!path.isAbsolute(result.migrationsPath)) {
-    result.migrationsPath = path.resolve(
-      result.basePath,
-      result.migrationsPath,
-    );
-  }
-
-  return result as RakeDbConfig;
-};
-
-export const getDatabaseAndUserFromOptions = (
-  options: AdapterOptions,
-): { database: string; user: string } => {
-  if (options.databaseURL) {
-    const url = new URL(options.databaseURL);
-    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.databaseURL) {
-    const url = new URL(options.databaseURL);
-
-    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, databaseURL: url.toString() };
-  } else {
-    return {
-      ...options,
-      ...set,
-    };
-  }
-};
-
-export const setAdminCredentialsToOptions = async (
-  options: AdapterOptions,
-  create?: boolean,
-): Promise<AdapterOptions | undefined> => {
-  const confirm = await prompts([
-    {
-      message: `Would you like to share admin credentials to ${
-        create ? 'create' : 'drop'
-      } a database`,
-      type: 'confirm',
-      name: 'confirm',
-      initial: true,
-    },
-  ]);
-
-  if (!confirm.confirm) {
-    return;
-  }
-
-  const values = await prompts([
-    {
-      message: 'Enter admin user:',
-      type: 'text',
-      name: 'user',
-      initial: 'postgres',
-      min: 1,
-    },
-    {
-      message: 'Enter admin password:',
-      type: 'password',
-      name: 'password',
-    },
-  ]);
-
-  return setAdapterOptions(options, {
-    ...values,
-    password: values.password || undefined,
-  });
-};
-
-export const createSchemaMigrations = async (
-  db: Adapter,
-  config: Pick<RakeDbConfig, 'migrationsTable'>,
-) => {
-  try {
-    await db.query(
-      `CREATE TABLE ${quoteWithSchema({
-        name: 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: RakeDbConfig,
-  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.resolve(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(', ');
-};
-
-export const quoteWithSchema = ({
-  schema,
-  name,
-}: {
-  schema?: string;
-  name: string;
-}) => {
-  return schema ? `"${schema}"."${name}"` : `"${name}"`;
-};
-
-export const getSchemaAndTableFromName = (
-  name: string,
-): [string | undefined, string] => {
-  const index = name.indexOf('.');
-  return index !== -1
-    ? [name.slice(0, index), name.slice(index + 1)]
-    : [undefined, name];
-};
-
-export const quoteSchemaTable = ({
-  schema,
-  name,
-}: {
-  schema?: string;
-  name: string;
-}) => {
-  return singleQuote(schema ? `${schema}.${name}` : name);
-};
-
-export const makePopulateEnumQuery = (item: EnumColumn): TableQuery => {
-  const [schema, name] = getSchemaAndTableFromName(item.enumName);
-  return {
-    text: `SELECT unnest(enum_range(NULL::${quoteWithSchema({
-      schema,
-      name,
-    })}))::text`,
-    then(result) {
-      // populate empty options array with values from db
-      item.options.push(...result.rows.map(([value]) => value));
-    },
-  };
-};

package/src/errors.ts

@@ -1,3 +0,0 @@
-export class RakeDbError extends Error {}
-
-export class NoPrimaryKey extends RakeDbError {}

package/src/index.ts

@@ -1,8 +0,0 @@
-export * from './commands/createOrDrop';
-export * from './commands/generate';
-export * from './commands/migrateOrRollback';
-export { change } from './migration/change';
-export * from './migration/migration';
-export { rakeDb } from './rakeDb';
-export * from './ast';
-export type { RakeDbConfig, AppCodeUpdater } from './common';

package/src/migration/change.test.ts

@@ -1,16 +0,0 @@
-import { change, clearChanges, getCurrentChanges } from './change';
-
-describe('change', () => {
-  const fn = async () => {};
-
-  it('should push callback to currentChanges', () => {
-    change(fn);
-    expect(getCurrentChanges()).toEqual([fn]);
-  });
-
-  it('should clear changes', () => {
-    getCurrentChanges().push(fn);
-    clearChanges();
-    expect(getCurrentChanges()).toEqual([]);
-  });
-});

package/src/migration/change.ts

@@ -1,15 +0,0 @@
-import { Migration } from './migration';
-
-const currentChanges: ChangeCallback[] = [];
-
-export type ChangeCallback = (db: Migration, up: boolean) => Promise<void>;
-
-export const change = (fn: ChangeCallback) => {
-  currentChanges.push(fn);
-};
-
-export const clearChanges = () => {
-  currentChanges.length = 0;
-};
-
-export const getCurrentChanges = () => currentChanges;