orchid-orm 1.5.29 → 1.5.31

package/src/codegen/updateTableFile/renameTable.test.ts

@@ -1,124 +0,0 @@
-import { updateTableFile } from './updateTableFile';
-import { asMock, ast, makeTestWritten, tablePath } from '../testUtils';
-import path from 'path';
-import fs from 'fs/promises';
-
-jest.mock('fs/promises', () => ({
-  mkdir: jest.fn(),
-  readFile: jest.fn(),
-  writeFile: jest.fn(),
-}));
-
-const baseTablePath = path.resolve('baseTable.ts');
-const baseTableName = 'BaseTable';
-const params = { baseTablePath, baseTableName, tablePath };
-
-const testWritten = makeTestWritten(tablePath('some'));
-
-describe('renameTable', () => {
-  beforeEach(() => {
-    jest.resetAllMocks();
-  });
-
-  it('should change `table` property', async () => {
-    asMock(fs.readFile)
-      .mockResolvedValue(`import { BaseTable } from '../baseTable';
-
-export class SomeTable extends BaseTable {
-  table = 'some';
-  columns = this.setColumns((t) => ({}));
-}`);
-
-    await updateTableFile({
-      ...params,
-      ast: ast.renameTable,
-    });
-
-    testWritten(`import { BaseTable } from '../baseTable';
-
-export class SomeTable extends BaseTable {
-  table = 'another';
-  columns = this.setColumns((t) => ({}));
-}`);
-  });
-
-  it('should change `schema` property', async () => {
-    asMock(fs.readFile)
-      .mockResolvedValue(`import { BaseTable } from '../baseTable';
-
-export class SomeTable extends BaseTable {
-  schema = 'one';
-  table = 'some';
-  columns = this.setColumns((t) => ({}));
-}`);
-
-    await updateTableFile({
-      ...params,
-      ast: {
-        ...ast.renameTable,
-        fromSchema: 'one',
-        toSchema: 'two',
-      },
-    });
-
-    testWritten(`import { BaseTable } from '../baseTable';
-
-export class SomeTable extends BaseTable {
-  schema = 'two';
-  table = 'another';
-  columns = this.setColumns((t) => ({}));
-}`);
-  });
-
-  it('should remove `schema` property', async () => {
-    asMock(fs.readFile)
-      .mockResolvedValue(`import { BaseTable } from '../baseTable';
-
-export class SomeTable extends BaseTable {
-  schema = 'one';
-  table = 'some';
-  columns = this.setColumns((t) => ({}));
-}`);
-
-    await updateTableFile({
-      ...params,
-      ast: {
-        ...ast.renameTable,
-        fromSchema: 'one',
-      },
-    });
-
-    testWritten(`import { BaseTable } from '../baseTable';
-
-export class SomeTable extends BaseTable {
-  table = 'another';
-  columns = this.setColumns((t) => ({}));
-}`);
-  });
-
-  it('should add `schema` property', async () => {
-    asMock(fs.readFile)
-      .mockResolvedValue(`import { BaseTable } from '../baseTable';
-
-export class SomeTable extends BaseTable {
-  table = 'some';
-  columns = this.setColumns((t) => ({}));
-}`);
-
-    await updateTableFile({
-      ...params,
-      ast: {
-        ...ast.renameTable,
-        toSchema: 'schema',
-      },
-    });
-
-    testWritten(`import { BaseTable } from '../baseTable';
-
-export class SomeTable extends BaseTable {
-  schema = 'schema';
-  table = 'another';
-  columns = this.setColumns((t) => ({}));
-}`);
-  });
-});

package/src/codegen/updateTableFile/renameTable.ts

@@ -1,67 +0,0 @@
-import { UpdateTableFileParams } from './updateTableFile';
-import { RakeDbAst } from 'rake-db';
-import fs from 'fs/promises';
-import { FileChanges } from '../fileChanges';
-import { ts } from '../tsUtils';
-import { toPascalCase } from '../../utils';
-import { Expression } from 'typescript';
-import { singleQuote } from 'pqb';
-
-export const renameTable = async ({
-  ast,
-  ...params
-}: UpdateTableFileParams & { ast: RakeDbAst.RenameTable }) => {
-  const tablePath = params.tablePath(ast.from);
-  const content = await fs.readFile(tablePath, 'utf-8').catch(() => undefined);
-  if (!content) return;
-
-  const changes = new FileChanges(content);
-  const statements = ts.getStatements(content);
-  const className = toPascalCase(ast.from) + 'Table';
-
-  const changeSchema = ast.fromSchema !== ast.toSchema;
-
-  for (const node of ts.class.iterate(statements)) {
-    if (node.name?.escapedText !== className) continue;
-
-    const addSchema =
-      changeSchema &&
-      ast.toSchema &&
-      !node.members.some((member) => ts.prop.getName(member) === 'schema');
-
-    if (addSchema && ast.toSchema) {
-      changes.add(
-        node.members.pos,
-        `\n  schema = ${singleQuote(ast.toSchema)};`,
-      );
-    }
-
-    for (const member of node.members) {
-      const name = ts.prop.getName(member);
-
-      if (name !== 'table' && !(changeSchema && name === 'schema')) continue;
-
-      const { initializer: value } = member as unknown as {
-        initializer?: Expression;
-      };
-
-      if (!value) continue;
-
-      if (name === 'schema') {
-        if (ast.toSchema) {
-          changes.replace(
-            value.pos,
-            value.end,
-            ` ${singleQuote(ast.toSchema)}`,
-          );
-        } else {
-          changes.remove(member.pos, member.end);
-        }
-      } else {
-        changes.replace(value.pos, value.end, ` ${singleQuote(ast.to)}`);
-      }
-    }
-  }
-
-  await fs.writeFile(tablePath, changes.apply());
-};

package/src/codegen/updateTableFile/updateTableFile.ts

@@ -1,22 +0,0 @@
-import { RakeDbAst } from 'rake-db';
-import { createTable } from './createTable';
-import { changeTable } from './changeTable';
-import { renameTable } from './renameTable';
-
-export type UpdateTableFileParams = {
-  baseTablePath: string;
-  baseTableName: string;
-  tablePath: (name: string) => string;
-  ast: RakeDbAst;
-};
-
-export const updateTableFile = async (params: UpdateTableFileParams) => {
-  const { ast } = params;
-  if (ast.type === 'table' && ast.action === 'create') {
-    await createTable({ ...params, ast });
-  } else if (ast.type === 'changeTable') {
-    await changeTable({ ...params, ast });
-  } else if (ast.type === 'renameTable') {
-    await renameTable({ ...params, ast });
-  }
-};

package/src/codegen/utils.ts

@@ -1,13 +0,0 @@
-import path from 'path';
-
-export const getImportPath = (from: string, to: string) => {
-  const rel = path
-    .relative(path.dirname(from), to)
-    .split(path.sep)
-    .join(path.posix.sep);
-
-  const importPath =
-    rel.startsWith('./') || rel.startsWith('../') ? rel : `./${rel}`;
-
-  return importPath.replace(/\.[tj]s$/, '');
-};

package/src/index.ts

@@ -1,5 +0,0 @@
-export * from './table';
-export * from './orm';
-export * from './repo';
-export * from './codegen/appCodeUpdater';
-export { columnTypes } from 'pqb';

package/src/orm.test.ts

@@ -1,92 +0,0 @@
-import { OrchidORM, orchidORM } from './orm';
-import {
-  assertType,
-  expectSql,
-  userData,
-  useTestDatabase,
-} from './test-utils/test-utils';
-import { pgConfig } from './test-utils/test-db';
-import { createBaseTable } from './table';
-
-describe('orm', () => {
-  useTestDatabase();
-
-  let db:
-    | OrchidORM<{ user: typeof UserTable; profile: typeof ProfileTable }>
-    | undefined;
-
-  afterEach(async () => {
-    if (db) await db.$close();
-  });
-
-  const BaseTable = createBaseTable();
-
-  type User = UserTable['columns']['type'];
-  class UserTable extends BaseTable {
-    table = 'user';
-    columns = this.setColumns((t) => ({
-      id: t.serial().primaryKey(),
-      name: t.text(1, 10),
-      password: t.text(1, 10),
-    }));
-  }
-
-  class ProfileTable extends BaseTable {
-    table = 'profile';
-    columns = this.setColumns((t) => ({
-      id: t.serial().primaryKey(),
-    }));
-  }
-
-  it('should return object with provided adapter, close and transaction method, tables', () => {
-    db = orchidORM(pgConfig, {
-      user: UserTable,
-      profile: ProfileTable,
-    });
-
-    expect('$adapter' in db).toBe(true);
-    expect(db.$close).toBeInstanceOf(Function);
-    expect(db.$transaction).toBeInstanceOf(Function);
-    expect(Object.keys(db)).toEqual(
-      expect.arrayContaining(['user', 'profile']),
-    );
-  });
-
-  it('should return table which is a queryable interface', async () => {
-    db = orchidORM(pgConfig, {
-      user: UserTable,
-      profile: ProfileTable,
-    });
-
-    const { id, name } = await db.user.create(userData);
-
-    const query = db.user.select('id', 'name').where({ id: { gt: 0 } });
-
-    expectSql(
-      query.toSql(),
-      `
-        SELECT "user"."id", "user"."name"
-        FROM "user"
-        WHERE "user"."id" > $1
-      `,
-      [0],
-    );
-
-    const result = await query;
-    expect(result).toEqual([{ id, name }]);
-
-    assertType<typeof result, Pick<User, 'id' | 'name'>[]>();
-  });
-
-  it('should be able to turn on autoPreparedStatements', () => {
-    db = orchidORM(
-      { ...pgConfig, autoPreparedStatements: true },
-      {
-        user: UserTable,
-        profile: ProfileTable,
-      },
-    );
-
-    expect(db.user.query.autoPreparedStatements).toBe(true);
-  });
-});

package/src/orm.ts

@@ -1,98 +0,0 @@
-import {
-  Adapter,
-  Db,
-  AdapterOptions,
-  QueryLogOptions,
-  columnTypes,
-  NoPrimaryKeyOption,
-  anyShape,
-  DbTableOptions,
-} from 'pqb';
-import { DbTable, Table, TableClasses } from './table';
-import { applyRelations } from './relations/relations';
-import { transaction } from './transaction';
-
-export type OrchidORM<T extends TableClasses> = {
-  [K in keyof T]: DbTable<T[K]>;
-} & {
-  $transaction: typeof transaction;
-  $adapter: Adapter;
-  $queryBuilder: Db;
-  $close(): Promise<void>;
-};
-
-export const orchidORM = <T extends TableClasses>(
-  {
-    log,
-    logger,
-    autoPreparedStatements,
-    noPrimaryKey = 'error',
-    ...options
-  }: ({ adapter: Adapter } | Omit<AdapterOptions, 'log'>) &
-    QueryLogOptions & {
-      autoPreparedStatements?: boolean;
-      noPrimaryKey?: NoPrimaryKeyOption;
-    },
-  tables: T,
-): OrchidORM<T> => {
-  const adapter = 'adapter' in options ? options.adapter : new Adapter(options);
-  const commonOptions = {
-    log,
-    logger,
-    autoPreparedStatements,
-    noPrimaryKey,
-  };
-  const qb = new Db(
-    adapter,
-    undefined as unknown as Db,
-    undefined,
-    anyShape,
-    columnTypes,
-    commonOptions,
-  );
-  qb.queryBuilder = qb as unknown as Db;
-
-  const result = {
-    $transaction: transaction,
-    $adapter: adapter,
-    $queryBuilder: qb,
-    $close: () => adapter.close(),
-  } as unknown as OrchidORM<TableClasses>;
-
-  const tableInstances: Record<string, Table> = {};
-
-  for (const key in tables) {
-    if (key[0] === '$') {
-      throw new Error(`Table class name must not start with $`);
-    }
-
-    const table = new tables[key]();
-    tableInstances[key] = table;
-
-    const options: DbTableOptions = {
-      ...commonOptions,
-      schema: table.schema,
-    };
-
-    if (table.noPrimaryKey) options.noPrimaryKey = 'ignore';
-
-    const dbTable = new Db(
-      adapter,
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      qb as any,
-      table.table,
-      table.columns.shape,
-      table.columnTypes,
-      options,
-    );
-
-    (dbTable as unknown as { definedAs: string }).definedAs = key;
-    (dbTable as unknown as { db: unknown }).db = result;
-
-    (result as Record<string, unknown>)[key] = dbTable;
-  }
-
-  applyRelations(qb, tableInstances, result);
-
-  return result as unknown as OrchidORM<T>;
-};