orchid-orm 1.5.28 → 1.5.30

package/src/codegen/createBaseTableFile.ts

@@ -1,31 +0,0 @@
-import { AppCodeUpdaterConfig } from './appCodeUpdater';
-import fs from 'fs/promises';
-import path from 'path';
-
-type CreateBaseTableFileParams = Pick<
-  AppCodeUpdaterConfig,
-  'baseTablePath' | 'baseTableName'
->;
-
-export const createBaseTableFile = async ({
-  baseTableName,
-  baseTablePath,
-}: CreateBaseTableFileParams) => {
-  await fs.mkdir(path.dirname(baseTablePath), { recursive: true });
-
-  await fs
-    .writeFile(
-      baseTablePath,
-      `import { createBaseTable } from 'orchid-orm';
-
-export const ${baseTableName} = createBaseTable();
-`,
-      {
-        flag: 'wx',
-      },
-    )
-    .catch((err) => {
-      if (err.code === 'EEXIST') return;
-      throw err;
-    });
-};

package/src/codegen/fileChanges.ts

@@ -1,41 +0,0 @@
-export class FileChanges {
-  private ranges: ([from: number, to: number] | string)[] = [];
-
-  constructor(public content: string) {}
-
-  add(at: number, text: string, end = at) {
-    if (this.ranges.length === 0) {
-      this.ranges.push([0, at], text, [end, this.content.length]);
-    } else {
-      const last = this.ranges[this.ranges.length - 1] as [number, number];
-      last[1] = at;
-      this.ranges.push(text, [end, this.content.length]);
-    }
-  }
-
-  replace(from: number, to: number, text: string) {
-    this.add(from, text, to);
-  }
-
-  remove(from: number, to: number) {
-    if (this.ranges.length === 0) {
-      this.ranges.push([0, from], [to, this.content.length]);
-    } else {
-      const last = this.ranges[this.ranges.length - 1] as [number, number];
-      last[1] = from;
-      this.ranges.push([to, this.content.length]);
-    }
-  }
-
-  apply() {
-    return this.ranges.length
-      ? this.ranges
-          .map((item) =>
-            typeof item === 'string'
-              ? item
-              : this.content.slice(item[0], item[1]),
-          )
-          .join('')
-      : this.content;
-  }
-}

package/src/codegen/testUtils.ts

@@ -1,56 +0,0 @@
-import { RakeDbAst } from 'rake-db';
-import { columnTypes } from 'pqb';
-import path from 'path';
-import fs from 'fs/promises';
-
-export const asMock = (fn: unknown) => fn as jest.Mock;
-export const tablePath = (table: string) =>
-  path.resolve(`tables/${table}.table.ts`);
-
-const makeAst = () => {
-  const addTable: RakeDbAst.Table = {
-    type: 'table',
-    action: 'create',
-    name: 'some',
-    shape: {
-      id: columnTypes.serial().primaryKey(),
-    },
-    noPrimaryKey: 'error',
-    indexes: [],
-    foreignKeys: [],
-  };
-
-  const dropTable: RakeDbAst.Table = {
-    ...addTable,
-    action: 'drop',
-  };
-
-  const renameTable: RakeDbAst.RenameTable = {
-    type: 'renameTable',
-    from: 'some',
-    to: 'another',
-  };
-
-  const tableData = {
-    indexes: [],
-    foreignKeys: [],
-  };
-
-  const changeTable: RakeDbAst.ChangeTable = {
-    type: 'changeTable',
-    name: 'some',
-    shape: {},
-    add: tableData,
-    drop: tableData,
-  };
-
-  return { addTable, dropTable, renameTable, changeTable };
-};
-
-export const ast = makeAst();
-
-export const makeTestWritten = (path: string) => (expected: string) => {
-  const [args] = asMock(fs.writeFile).mock.calls;
-  expect(args[0]).toBe(path);
-  expect(args[1]).toBe(expected);
-};

package/src/codegen/tsUtils.ts

@@ -1,180 +0,0 @@
-import {
-  CallExpression,
-  ClassDeclaration,
-  ComputedPropertyName,
-  Expression,
-  Identifier,
-  ImportDeclaration,
-  NamedImports,
-  Node,
-  NodeArray,
-  NumericLiteral,
-  ObjectLiteralElement,
-  ObjectLiteralExpression,
-  PrivateIdentifier,
-  PropertyAccessExpression,
-  PropertyAssignment,
-  ShorthandPropertyAssignment,
-  Statement,
-  StringLiteral,
-  VariableStatement,
-  ThisExpression,
-  ArrowFunction,
-  ParenthesizedExpression,
-  PropertyName,
-  SpreadAssignment,
-  ArrayLiteralExpression,
-} from 'typescript';
-import typescript from 'typescript';
-const { createSourceFile, ScriptTarget, SyntaxKind } = typescript;
-
-const iterate = <T>(
-  kind: number,
-): ((statements: NodeArray<Statement>) => Generator<T, void, unknown>) => {
-  return function* (statements: NodeArray<Statement>) {
-    for (const node of statements) {
-      if (node.kind === kind) {
-        yield node as T;
-      }
-    }
-  };
-};
-
-const isNode = <T extends Expression | ObjectLiteralElement | Node>(
-  kind: number,
-) => {
-  return (node?: Expression | ObjectLiteralElement | Node): node is T => {
-    return node?.kind === kind;
-  };
-};
-
-export const ts = {
-  getStatements(content: string): NodeArray<Statement> {
-    const { statements } = createSourceFile(
-      'file.ts',
-      content,
-      ScriptTarget.Latest,
-      true,
-    );
-    return statements;
-  },
-  is: {
-    call: isNode<CallExpression>(SyntaxKind.CallExpression),
-    objectLiteral: isNode<ObjectLiteralExpression>(
-      SyntaxKind.ObjectLiteralExpression,
-    ),
-    propertyAssignment: isNode<PropertyAssignment>(
-      SyntaxKind.PropertyAssignment,
-    ),
-    shorthandPropertyAssignment: isNode<ShorthandPropertyAssignment>(
-      SyntaxKind.ShorthandPropertyAssignment,
-    ),
-    identifier: isNode<Identifier>(SyntaxKind.Identifier),
-    stringLiteral: isNode<StringLiteral>(SyntaxKind.StringLiteral),
-    arrayLiteral: isNode<ArrayLiteralExpression>(
-      SyntaxKind.ArrayLiteralExpression,
-    ),
-    numericLiteral: isNode<NumericLiteral>(SyntaxKind.NumericLiteral),
-    computedPropertyName: isNode<ComputedPropertyName>(
-      SyntaxKind.ComputedPropertyName,
-    ),
-    privateIdentifier: isNode<PrivateIdentifier>(SyntaxKind.PrivateIdentifier),
-    this: isNode<ThisExpression>(SyntaxKind.ThisKeyword),
-    propertyAccess: isNode<PropertyAccessExpression>(
-      SyntaxKind.PropertyAccessExpression,
-    ),
-    arrowFunction: isNode<ArrowFunction>(SyntaxKind.ArrowFunction),
-    parenthesizedExpression: isNode<ParenthesizedExpression>(
-      SyntaxKind.ParenthesizedExpression,
-    ),
-    spreadAssignment: isNode<SpreadAssignment>(SyntaxKind.SpreadAssignment),
-  },
-  import: {
-    iterate: iterate<ImportDeclaration>(SyntaxKind.ImportDeclaration),
-    *iterateWithSource(statements: NodeArray<Statement>, path: string) {
-      for (const node of ts.import.iterate(statements)) {
-        if (ts.import.getSource(node) !== path) continue;
-        yield node;
-      }
-    },
-    getSource(node: ImportDeclaration) {
-      return node.moduleSpecifier.getText().slice(1, -1);
-    },
-    getEndPos(statements: NodeArray<Statement>) {
-      let end = 0;
-      for (const node of ts.import.iterate(statements)) {
-        end = node.end;
-      }
-      return end;
-    },
-    getStatementsImportedName(
-      statements: NodeArray<Statement>,
-      path: string,
-      key: string,
-    ) {
-      for (const node of ts.import.iterateWithSource(statements, path)) {
-        const name = ts.import.getImportName(node, key);
-        if (name) return name;
-      }
-
-      return;
-    },
-    getImportName(node: ImportDeclaration, key: string) {
-      if (!node.importClause) return;
-
-      const elements = (node.importClause.namedBindings as NamedImports)
-        ?.elements;
-
-      if (!elements) return;
-
-      for (const element of elements) {
-        if (
-          element.propertyName?.escapedText === key ||
-          element.name.escapedText === key
-        ) {
-          return element.name.escapedText.toString();
-        }
-      }
-
-      return;
-    },
-  },
-  variable: {
-    iterate: iterate<VariableStatement>(SyntaxKind.VariableStatement),
-    *iterateDeclarations(statements: NodeArray<Statement>) {
-      for (const node of ts.variable.iterate(statements)) {
-        for (const dec of node.declarationList.declarations) {
-          yield dec;
-        }
-      }
-    },
-  },
-  class: {
-    iterate: iterate<ClassDeclaration>(SyntaxKind.ClassDeclaration),
-  },
-  prop: {
-    getName({ name }: { name?: PropertyName }) {
-      if (ts.is.identifier(name)) {
-        return name.escapedText;
-      } else {
-        return name?.getText();
-      }
-    },
-    getValue(prop: ObjectLiteralElement) {
-      if (ts.is.propertyAssignment(prop)) {
-        return prop.initializer.getText();
-      } else if (ts.is.shorthandPropertyAssignment(prop)) {
-        return prop.name.escapedText.toString();
-      } else {
-        return;
-      }
-    },
-  },
-  spaces: {
-    getAtLine(content: string, pos: number) {
-      const lines = content.slice(0, pos).split('\n');
-      const last = lines[lines.length - 1];
-      return last.match(/^\s+/)?.[0] || '';
-    },
-  },
-};

package/src/codegen/updateMainFile.test.ts

@@ -1,253 +0,0 @@
-import { updateMainFile } from './updateMainFile';
-import * as path from 'path';
-import * as fs from 'fs/promises';
-import { asMock, ast, makeTestWritten, tablePath } from './testUtils';
-
-jest.mock('fs/promises', () => ({
-  readFile: jest.fn(),
-  writeFile: jest.fn(),
-  mkdir: jest.fn(),
-}));
-
-const mainFilePath = path.resolve('db.ts');
-const testWritten = makeTestWritten(mainFilePath);
-const options = { databaseURL: 'url' };
-
-describe('updateMainFile', () => {
-  beforeEach(() => {
-    jest.resetAllMocks();
-  });
-
-  describe('add table', () => {
-    it('should create file if not exist and add a table', async () => {
-      asMock(fs.readFile).mockRejectedValue(
-        Object.assign(new Error(), { code: 'ENOENT' }),
-      );
-
-      await updateMainFile(mainFilePath, tablePath, ast.addTable, options);
-
-      expect(asMock(fs.mkdir)).toBeCalledWith(path.dirname(mainFilePath), {
-        recursive: true,
-      });
-
-      testWritten(`import { orchidORM } from 'orchid-orm';
-import { SomeTable } from './tables/some.table';
-
-export const db = orchidORM(
-  {
-    databaseURL: 'url',
-  },
-  {
-    some: SomeTable,
-  }
-);
-`);
-    });
-
-    it('should add table', async () => {
-      asMock(fs.readFile).mockResolvedValue(`
-import { orchidORM } from 'orchid-orm';
-
-export const db = orchidORM({}, {});
-`);
-
-      await updateMainFile(mainFilePath, tablePath, ast.addTable, options);
-
-      testWritten(`
-import { orchidORM } from 'orchid-orm';
-import { SomeTable } from './tables/some.table';
-
-export const db = orchidORM({}, {
-  some: SomeTable,
-});
-`);
-    });
-
-    it('should handle import as', async () => {
-      asMock(fs.readFile).mockResolvedValue(`
-import { orchidORM as custom } from 'orchid-orm';
-
-export const db = custom({}, {});
-`);
-
-      await updateMainFile(mainFilePath, tablePath, ast.addTable, options);
-
-      testWritten(`
-import { orchidORM as custom } from 'orchid-orm';
-import { SomeTable } from './tables/some.table';
-
-export const db = custom({}, {
-  some: SomeTable,
-});
-`);
-    });
-
-    it('should handle object list with elements', async () => {
-      asMock(fs.readFile).mockResolvedValue(`
-import { orchidORM } from 'orchid-orm';
-import { Other } from './tables/other';
-
-export const db = orchidORM({}, {
-  other: Other,
-});
-`);
-
-      await updateMainFile(mainFilePath, tablePath, ast.addTable, options);
-
-      testWritten(`
-import { orchidORM } from 'orchid-orm';
-import { Other } from './tables/other';
-import { SomeTable } from './tables/some.table';
-
-export const db = orchidORM({}, {
-  other: Other,
-  some: SomeTable,
-});
-`);
-    });
-
-    it('should handle object list without ending coma', async () => {
-      asMock(fs.readFile).mockResolvedValue(`
-import { orchidORM } from 'orchid-orm';
-import { MyTable } from './tables/my.table';
-
-export const db = orchidORM({}, {
-  my: MyTable,
-});
-`);
-
-      await updateMainFile(mainFilePath, tablePath, ast.addTable, options);
-
-      testWritten(`
-import { orchidORM } from 'orchid-orm';
-import { MyTable } from './tables/my.table';
-import { SomeTable } from './tables/some.table';
-
-export const db = orchidORM({}, {
-  my: MyTable,
-  some: SomeTable,
-});
-`);
-    });
-
-    it('should not add table if it is already added', async () => {
-      asMock(fs.readFile).mockResolvedValue(`
-import { orchidORM } from 'orchid-orm';
-import { SomeTable } from './tables/some.table';
-
-export const db = orchidORM({}, {
-  some: SomeTable
-});
-`);
-
-      await updateMainFile(mainFilePath, tablePath, ast.addTable, options);
-
-      expect(fs.writeFile).not.toBeCalled();
-    });
-  });
-
-  describe('drop table', () => {
-    it('should remove table', async () => {
-      asMock(fs.readFile).mockResolvedValue(`
-import { orchidORM } from 'orchid-orm';
-import { SomeTable } from './tables/some.table';
-
-export const db = orchidORM({}, {
-  some: SomeTable,
-});
-`);
-
-      await updateMainFile(mainFilePath, tablePath, ast.dropTable, options);
-
-      testWritten(`
-import { orchidORM } from 'orchid-orm';
-
-export const db = orchidORM({}, {
-});
-`);
-    });
-
-    it('should remove aliased import', async () => {
-      asMock(fs.readFile).mockResolvedValue(`
-import { orchidORM } from 'orchid-orm';
-import { SomeTable as koko } from './tables/some.table';
-
-export const db = orchidORM({}, {
-  koko: koko,
-});
-`);
-
-      await updateMainFile(mainFilePath, tablePath, ast.dropTable, options);
-
-      testWritten(`
-import { orchidORM } from 'orchid-orm';
-
-export const db = orchidORM({}, {
-});
-`);
-    });
-
-    it('should remove short form of key and value', async () => {
-      asMock(fs.readFile).mockResolvedValue(`
-import { orchidORM } from 'orchid-orm';
-import { SomeTable as koko } from './tables/some.table';
-
-export const db = orchidORM({}, {
-  koko,
-});
-`);
-
-      await updateMainFile(mainFilePath, tablePath, ast.dropTable, options);
-
-      testWritten(`
-import { orchidORM } from 'orchid-orm';
-
-export const db = orchidORM({}, {
-});
-`);
-    });
-
-    it('should not remove other tables', async () => {
-      asMock(fs.readFile).mockResolvedValue(`
-import { orchidORM } from 'orchid-orm';
-import { One } from './tables/one';
-import { SomeTable } from './tables/some.table';
-import { Two } from './tables/two';
-
-export const db = orchidORM({}, {
-  one,
-  some: SomeTable,
-  two,
-});
-`);
-
-      await updateMainFile(mainFilePath, tablePath, ast.dropTable, options);
-
-      testWritten(`
-import { orchidORM } from 'orchid-orm';
-import { One } from './tables/one';
-import { Two } from './tables/two';
-
-export const db = orchidORM({}, {
-  one,
-  two,
-});
-`);
-    });
-
-    it('should not insert table if table with same key exists, disregarding the import path', async () => {
-      asMock(fs.readFile).mockResolvedValue(`
-import { orchidORM } from 'orchid-orm';
-import { X } from './x';
-
-export const db = orchidORM({}, {
-  some: X,
-});
-`);
-
-      await updateMainFile(mainFilePath, tablePath, ast.addTable, options);
-
-      expect(fs.writeFile).not.toBeCalled();
-    });
-  });
-});