orchid-orm 1.3.15 → 1.4.16

package/src/appCodeUpdater/fileChanges.ts

@@ -0,0 +1,41 @@
+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/appCodeUpdater/testUtils.ts

@@ -0,0 +1,31 @@
+import { RakeDbAst } from 'rake-db';
+import { columnTypes } from 'pqb';
+
+const makeAst = () => {
+  const addTable: RakeDbAst.Table = {
+    type: 'table',
+    action: 'create',
+    name: 'table',
+    shape: {
+      id: columnTypes.serial().primaryKey(),
+    },
+    noPrimaryKey: 'ignore',
+    indexes: [],
+    foreignKeys: [],
+  };
+
+  const dropTable: RakeDbAst.Table = {
+    ...addTable,
+    action: 'drop',
+  };
+
+  const renameTable: RakeDbAst.RenameTable = {
+    type: 'renameTable',
+    from: 'table',
+    to: 'renamedTable',
+  };
+
+  return { addTable, dropTable, renameTable };
+};
+
+export const ast = makeAst();

package/src/appCodeUpdater/tsUtils.ts

@@ -0,0 +1,137 @@
+import {
+  CallExpression,
+  Expression,
+  ImportDeclaration,
+  NamedImports,
+  NodeArray,
+  ObjectLiteralElement,
+  ObjectLiteralExpression,
+  PropertyAssignment,
+  ShorthandPropertyAssignment,
+  Statement,
+  SyntaxKind,
+  VariableStatement,
+} from 'typescript';
+import path from 'path';
+
+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 { kind: number }>() => {
+  return <U extends T>(kind: number) => {
+    return (node?: T): node is U => {
+      return node?.kind === kind;
+    };
+  };
+};
+
+const isExpression = isNode<Expression>();
+const isObjectLiteral = isNode<ObjectLiteralElement>();
+
+export const ts = {
+  is: {
+    call: isExpression<CallExpression>(SyntaxKind.CallExpression),
+    objectLiteral: isExpression<ObjectLiteralExpression>(
+      SyntaxKind.ObjectLiteralExpression,
+    ),
+    propertyAssignment: isObjectLiteral<PropertyAssignment>(
+      SyntaxKind.PropertyAssignment,
+    ),
+    shorthandPropertyAssignment: isObjectLiteral<ShorthandPropertyAssignment>(
+      SyntaxKind.ShorthandPropertyAssignment,
+    ),
+  },
+  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;
+        }
+      }
+    },
+  },
+  prop: {
+    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;
+      }
+    },
+  },
+  path: {
+    getRelative(from: string, to: string) {
+      const rel = path.relative(path.dirname(from), to);
+      return rel.startsWith('./') || rel.startsWith('../') ? rel : `./${rel}`;
+    },
+  },
+  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/appCodeUpdater/updateMainFile.test.ts

@@ -0,0 +1,230 @@
+import { updateMainFile } from './updateMainFile';
+import * as path from 'path';
+import * as fs from 'fs/promises';
+import { ast } from './testUtils';
+
+jest.mock('fs/promises', () => ({
+  readFile: jest.fn(),
+  writeFile: jest.fn(),
+}));
+
+const asMock = (fn: unknown) => fn as jest.Mock;
+
+const mainFilePath = path.resolve('db.ts');
+const tablePath = (table: string) => path.resolve(`tables/${table}`);
+
+describe('updateMainFile', () => {
+  beforeEach(() => {
+    jest.resetAllMocks();
+  });
+
+  it('should throw when file is not found', async () => {
+    asMock(fs.readFile).mockRejectedValue(new Error());
+
+    await expect(() =>
+      updateMainFile(mainFilePath, tablePath, ast.addTable),
+    ).rejects.toThrow();
+  });
+
+  describe('add table', () => {
+    it('should add table', async () => {
+      asMock(fs.readFile).mockResolvedValue(`
+import { orchidORM } from 'orchid-orm';
+
+export const db = orchidORM({}, {});
+`);
+
+      await updateMainFile(mainFilePath, tablePath, ast.addTable);
+
+      expect(fs.writeFile).toBeCalledWith(
+        mainFilePath,
+        `
+import { orchidORM } from 'orchid-orm';
+import { Table } from './tables/table';
+
+export const db = orchidORM({}, {
+  table: Table,
+});
+`,
+      );
+    });
+
+    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);
+
+      expect(fs.writeFile).toBeCalledWith(
+        mainFilePath,
+        `
+import { orchidORM as custom } from 'orchid-orm';
+import { Table } from './tables/table';
+
+export const db = custom({}, {
+  table: Table,
+});
+`,
+      );
+    });
+
+    it('should handle object list with elements', async () => {
+      asMock(fs.readFile).mockResolvedValue(`
+import { orchidORM } from 'orchid-orm';
+import { Some } from './tables/some';
+
+export const db = orchidORM({}, {
+  some: Some,
+});
+`);
+
+      await updateMainFile(mainFilePath, tablePath, ast.addTable);
+
+      expect(fs.writeFile).toBeCalledWith(
+        mainFilePath,
+        `
+import { orchidORM } from 'orchid-orm';
+import { Some } from './tables/some';
+import { Table } from './tables/table';
+
+export const db = orchidORM({}, {
+  some: Some,
+  table: Table,
+});
+`,
+      );
+    });
+
+    it('should handle object list without ending coma', async () => {
+      asMock(fs.readFile).mockResolvedValue(`
+import { orchidORM } from 'orchid-orm';
+import { Some } from './tables/some';
+
+export const db = orchidORM({}, {
+  some: Some
+});
+`);
+
+      await updateMainFile(mainFilePath, tablePath, ast.addTable);
+
+      expect(fs.writeFile).toBeCalledWith(
+        mainFilePath,
+        `
+import { orchidORM } from 'orchid-orm';
+import { Some } from './tables/some';
+import { Table } from './tables/table';
+
+export const db = orchidORM({}, {
+  some: Some,
+  table: Table,
+});
+`,
+      );
+    });
+  });
+
+  describe('drop table', () => {
+    it('should remove table', async () => {
+      asMock(fs.readFile).mockResolvedValue(`
+import { orchidORM } from 'orchid-orm';
+import { Table } from './tables/table';
+
+export const db = orchidORM({}, {
+  table: Table,
+});
+`);
+
+      await updateMainFile(mainFilePath, tablePath, ast.dropTable);
+
+      expect(fs.writeFile).toBeCalledWith(
+        mainFilePath,
+        `
+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 { Table as koko } from './tables/table';
+
+export const db = orchidORM({}, {
+  koko: koko,
+});
+`);
+
+      await updateMainFile(mainFilePath, tablePath, ast.dropTable);
+
+      expect(fs.writeFile).toBeCalledWith(
+        mainFilePath,
+        `
+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 { Table as koko } from './tables/table';
+
+export const db = orchidORM({}, {
+  koko,
+});
+`);
+
+      await updateMainFile(mainFilePath, tablePath, ast.dropTable);
+
+      expect(fs.writeFile).toBeCalledWith(
+        mainFilePath,
+        `
+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 { Table } from './tables/table';
+import { Two } from './tables/two';
+
+export const db = orchidORM({}, {
+  one,
+  table: Table,
+  two,
+});
+`);
+
+      await updateMainFile(mainFilePath, tablePath, ast.dropTable);
+
+      expect(fs.writeFile).toBeCalledWith(
+        mainFilePath,
+        `
+import { orchidORM } from 'orchid-orm';
+import { One } from './tables/one';
+import { Two } from './tables/two';
+
+export const db = orchidORM({}, {
+  one,
+  two,
+});
+`,
+      );
+    });
+  });
+});

package/src/appCodeUpdater/updateMainFile.ts

@@ -0,0 +1,163 @@
+import { RakeDbAst } from 'rake-db';
+import fs from 'fs/promises';
+import {
+  createSourceFile,
+  NodeArray,
+  ObjectLiteralExpression,
+  ScriptTarget,
+  Statement,
+} from 'typescript';
+import { toCamelCase, toPascalCase } from '../utils';
+import { AppCodeUpdaterError } from './appCodeUpdater';
+import { FileChanges } from './fileChanges';
+import { ts } from './tsUtils';
+
+type Context = {
+  path: string;
+  tablePath: (name: string) => string;
+  statements: NodeArray<Statement>;
+  object: ObjectLiteralExpression;
+  content: string;
+  spaces: string;
+};
+
+const libraryName = 'orchid-orm';
+const importKey = 'orchidORM';
+
+export const updateMainFile = async (
+  path: string,
+  tablePath: (name: string) => string,
+  ast: RakeDbAst,
+) => {
+  const content = await fs.readFile(path, 'utf-8');
+
+  const { statements } = createSourceFile(
+    'file.ts',
+    content,
+    ScriptTarget.Latest,
+    true,
+  );
+
+  const importName = ts.import.getStatementsImportedName(
+    statements,
+    libraryName,
+    importKey,
+  );
+  if (!importName) {
+    throw new AppCodeUpdaterError(
+      `Main file does not contain import of orchid-orm`,
+    );
+  }
+
+  const object = getTablesListObject(importName, statements);
+  if (!object) {
+    throw new Error('List of tables is not found in main file');
+  }
+
+  const spaces = ts.spaces.getAtLine(content, object.end);
+
+  const context: Context = {
+    path,
+    tablePath,
+    statements,
+    object,
+    content,
+    spaces,
+  };
+
+  if (ast.type === 'table') {
+    if (ast.action === 'create') {
+      return fs.writeFile(path, createTable(context, ast));
+    } else {
+      return fs.writeFile(path, dropTable(context, ast));
+    }
+  }
+
+  // rename table is not handled because renaming of the class and the file is better to be done by the editor,
+  // editor can scan all project files, rename import path and imported class name
+};
+
+const createTable = (
+  { path, tablePath, statements, object, content, spaces }: Context,
+  ast: RakeDbAst.Table,
+) => {
+  const key = toCamelCase(ast.name);
+  const value = toPascalCase(ast.name);
+
+  const changes = new FileChanges(content);
+
+  const importPath = ts.path.getRelative(path, tablePath(ast.name));
+  const importPos = ts.import.getEndPos(statements);
+  changes.add(
+    importPos,
+    `${importPos === 0 ? '' : '\n'}import { ${value} } from '${importPath}';`,
+  );
+
+  let insert = `\n${spaces}  ${key}: ${value},`;
+  if (object.properties.length && !object.properties.hasTrailingComma) {
+    insert = `,${insert}`;
+  }
+  if (!content.slice(object.properties.end, object.end).includes('\n')) {
+    insert += `\n${spaces}`;
+  }
+  changes.add(object.properties.end, insert);
+
+  return changes.apply();
+};
+
+const dropTable = (
+  { path, tablePath, statements, object, content }: Context,
+  ast: RakeDbAst.Table,
+) => {
+  const changes = new FileChanges(content);
+
+  const importPath = ts.path.getRelative(path, tablePath(ast.name));
+  const tableClassName = toPascalCase(ast.name);
+  const importNames: string[] = [];
+  for (const node of ts.import.iterateWithSource(statements, importPath)) {
+    changes.remove(node.pos, node.end);
+
+    const name = ts.import.getImportName(node, tableClassName);
+    if (name && !importNames.includes(name)) {
+      importNames.push(name);
+    }
+  }
+
+  for (const prop of object.properties) {
+    const name = ts.prop.getValue(prop);
+    if (!name || !importNames.includes(name)) continue;
+
+    let { end } = prop;
+    if (content[end] === ',') end++;
+    changes.remove(prop.pos, end);
+  }
+
+  return changes.apply();
+};
+
+const getTablesListObject = (
+  importName: string,
+  statements: NodeArray<Statement>,
+): ObjectLiteralExpression | undefined => {
+  for (const node of ts.variable.iterateDeclarations(statements)) {
+    const call = node.initializer;
+    if (!ts.is.call(call)) continue;
+
+    if (call.expression.getText() !== importName) continue;
+
+    if (call.arguments.length !== 2) {
+      throw new Error(
+        'Invalid number of arguments when initializing orchid orm',
+      );
+    }
+
+    const object = call.arguments[1];
+    if (!ts.is.objectLiteral(object)) {
+      throw new Error('Second argument of orchidORM must be an object literal');
+    }
+
+    return object;
+  }
+
+  return;
+};

package/src/appCodeUpdater/updateTableFile.ts

@@ -0,0 +1,19 @@
+// import { RakeDbAst } from 'rake-db';
+//
+// export const updateTableFile = async (
+//   tablePath: (name: string) => string,
+//   ast: RakeDbAst,
+// ) => {
+//   if (ast.type === 'table') {
+//     if (ast.action === 'create') {
+//       createTable(tablePath, ast);
+//     }
+//   }
+// };
+//
+// const createTable = (
+//   tablePath: (name: string) => string,
+//   ast: RakeDbAst.Table,
+// ) => {
+//
+// };

package/src/index.ts

@@ -1,3 +1,7 @@
-export * from './model';
+export * from './table';
 export * from './orm';
 export * from './repo';
+export type {
+  appCodeUpdater,
+  AppCodeUpdaterConfig,
+} from './appCodeUpdater/appCodeUpdater';

package/src/orm.test.ts

@@ -6,21 +6,21 @@ import {
   useTestDatabase,
 } from './test-utils/test-utils';
 import { pgConfig } from './test-utils/test-db';
-import { createModel } from './model';
+import { createBaseTable } from './table';
 import { columnTypes } from 'pqb';
 
 describe('orm', () => {
   useTestDatabase();
 
-  const Model = createModel({
+  const BaseTable = createBaseTable({
     columnTypes: {
       ...columnTypes,
       text: (min = 0, max = Infinity) => columnTypes.text(min, max),
     },
   });
 
-  type User = UserModel['columns']['type'];
-  class UserModel extends Model {
+  type User = UserTable['columns']['type'];
+  class UserTable extends BaseTable {
     table = 'user';
     columns = this.setColumns((t) => ({
       id: t.serial().primaryKey(),
@@ -29,17 +29,17 @@ describe('orm', () => {
     }));
   }
 
-  class ProfileModel extends Model {
+  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, models', () => {
+  it('should return object with provided adapter, close and transaction method, tables', () => {
     const db = orchidORM(pgConfig, {
-      user: UserModel,
-      profile: ProfileModel,
+      user: UserTable,
+      profile: ProfileTable,
     });
 
     expect('$adapter' in db).toBe(true);
@@ -50,10 +50,10 @@ describe('orm', () => {
     );
   });
 
-  it('should return model which is a queryable interface', async () => {
+  it('should return table which is a queryable interface', async () => {
     const db = orchidORM(pgConfig, {
-      user: UserModel,
-      profile: ProfileModel,
+      user: UserTable,
+      profile: ProfileTable,
     });
 
     const { id, name } = await db.user.create(userData);
@@ -80,8 +80,8 @@ describe('orm', () => {
     const db = orchidORM(
       { ...pgConfig, autoPreparedStatements: true },
       {
-        user: UserModel,
-        profile: ProfileModel,
+        user: UserTable,
+        profile: ProfileTable,
       },
     );