orchid-orm 1.4.17 → 1.4.19

package/CHANGELOG.md

@@ -1,5 +1,20 @@
 # orchid-orm
 
+## 1.4.19
+
+### Patch Changes
+
+- Updated dependencies
+  - pqb@0.8.3
+
+## 1.4.18
+
+### Patch Changes
+
+- Add code generator to change project files after migrations
+- Updated dependencies
+  - pqb@0.8.2
+
 ## 1.4.17
 
 ### Patch Changes

package/dist/index.d.ts

@@ -231,8 +231,10 @@ declare const createRepo: <T extends Query, Methods extends MethodsBase<T>>(tabl
 
 declare type AppCodeUpdaterConfig = {
     tablePath(tableName: string): string;
+    baseTablePath: string;
+    baseTableName: string;
     mainFilePath: string;
 };
-declare const appCodeUpdater: () => AppCodeUpdater;
+declare const appCodeUpdater: (config: AppCodeUpdaterConfig) => AppCodeUpdater;
 
 export { AppCodeUpdaterConfig, DbTable, MapMethods, MapQueryMethods, MethodsBase, OrchidORM, QueryMethods, Repo, Table, TableClass, TableClasses, TableToDb, appCodeUpdater, createBaseTable, createRepo, orchidORM };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "orchid-orm",
-  "version": "1.4.17",
+  "version": "1.4.19",
   "description": "Postgres ORM",
   "homepage": "https://orchid-orm.netlify.app/guide/orm-setup-and-overview.html",
   "repository": {
@@ -31,14 +31,14 @@
   "author": "Roman Kushyn",
   "license": "ISC",
   "dependencies": {
-    "pqb": "0.8.1"
+    "pqb": "0.8.3"
   },
   "devDependencies": {
     "@swc/core": "^1.3.19",
     "rollup": "^2.79.0",
     "rollup-plugin-dts": "^4.2.2",
     "rollup-plugin-esbuild": "^4.10.1",
-    "orchid-orm-schema-to-zod": "0.2.1",
+    "orchid-orm-schema-to-zod": "0.2.3",
     "@swc/jest": "^0.2.21",
     "@types/jest": "^28.1.2",
     "@types/node": "^18.0.1",
@@ -50,7 +50,7 @@
     "rimraf": "^3.0.2",
     "tslib": "^2.4.0",
     "typescript": "^4.7.4",
-    "rake-db": "2.2.1"
+    "rake-db": "2.2.3"
   },
   "peerDependencies": {
     "typescript": "*"

package/src/appCodeUpdater/appCodeUpdater.test.ts

@@ -0,0 +1,42 @@
+import { appCodeUpdater } from './appCodeUpdater';
+import { asMock, ast } from './testUtils';
+import { updateMainFile } from './updateMainFile';
+import * as path from 'path';
+import { updateTableFile } from './updateTableFile/updateTableFile';
+
+jest.mock('./updateMainFile', () => ({
+  updateMainFile: jest.fn(),
+}));
+
+jest.mock('./updateTableFile/updateTableFile', () => ({
+  updateTableFile: jest.fn(),
+}));
+
+describe('appCodeUpdater', () => {
+  it('should call table and file updaters with proper arguments', async () => {
+    const params = {
+      tablePath: (table: string) => `tables/${table}.ts`,
+      baseTablePath: 'baseTable.ts',
+      baseTableName: 'BaseTable',
+      mainFilePath: 'db.ts',
+    };
+
+    const fn = appCodeUpdater(params);
+
+    await fn(ast.addTable);
+
+    const mainFilePath = path.resolve(params.mainFilePath);
+    const tablePath = path.resolve(params.tablePath('table'));
+
+    const main = asMock(updateMainFile).mock.calls[0];
+    expect(main[0]).toBe(mainFilePath);
+    expect(main[1]('table')).toBe(tablePath);
+    expect(main[2]).toBe(ast.addTable);
+
+    const [table] = asMock(updateTableFile).mock.calls[0];
+    expect(table.tablePath('table')).toBe(tablePath);
+    expect(table.baseTablePath).toBe(params.baseTablePath);
+    expect(table.baseTableName).toBe(params.baseTableName);
+    expect(table.mainFilePath).toBe(mainFilePath);
+  });
+});

package/src/appCodeUpdater/appCodeUpdater.ts

@@ -1,19 +1,30 @@
 import { AppCodeUpdater } from 'rake-db';
-// import * as path from 'path';
+import * as path from 'path';
+import { updateMainFile } from './updateMainFile';
+import { updateTableFile } from './updateTableFile/updateTableFile';
 
 export class AppCodeUpdaterError extends Error {}
 
 export type AppCodeUpdaterConfig = {
   tablePath(tableName: string): string;
+  baseTablePath: string;
+  baseTableName: string;
   mainFilePath: string;
 };
 
-export const appCodeUpdater = (): // config: AppCodeUpdaterConfig,
-AppCodeUpdater => {
-  // const tablePath = (name: string) => path.resolve(config.tablePath(name));
-  // const mainFilePath = path.resolve(config.mainFilePath);
+export const appCodeUpdater = (
+  config: AppCodeUpdaterConfig,
+): AppCodeUpdater => {
+  const params = {
+    ...config,
+    tablePath: (name: string) => path.resolve(config.tablePath(name)),
+    mainFilePath: path.resolve(config.mainFilePath),
+  };
 
   return async (ast) => {
-    console.log(ast);
+    await Promise.all([
+      updateMainFile(params.mainFilePath, params.tablePath, ast),
+      updateTableFile({ ...params, ast }),
+    ]);
   };
 };

package/src/appCodeUpdater/testUtils.ts

@@ -1,5 +1,10 @@
 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}.ts`);
 
 const makeAst = () => {
   const addTable: RakeDbAst.Table = {
@@ -9,7 +14,7 @@ const makeAst = () => {
     shape: {
       id: columnTypes.serial().primaryKey(),
     },
-    noPrimaryKey: 'ignore',
+    noPrimaryKey: 'error',
     indexes: [],
     foreignKeys: [],
   };
@@ -25,7 +30,26 @@ const makeAst = () => {
     to: 'renamedTable',
   };
 
-  return { addTable, dropTable, renameTable };
+  const tableData = {
+    indexes: [],
+    foreignKeys: [],
+  };
+
+  const changeTable: RakeDbAst.ChangeTable = {
+    type: 'changeTable',
+    name: 'table',
+    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/appCodeUpdater/tsUtils.ts

@@ -1,18 +1,33 @@
 import {
   CallExpression,
+  ClassDeclaration,
+  ComputedPropertyName,
+  createSourceFile,
   Expression,
+  Identifier,
   ImportDeclaration,
   NamedImports,
+  Node,
   NodeArray,
+  NumericLiteral,
   ObjectLiteralElement,
   ObjectLiteralExpression,
+  PrivateIdentifier,
+  PropertyAccessExpression,
   PropertyAssignment,
+  ScriptTarget,
   ShorthandPropertyAssignment,
   Statement,
+  StringLiteral,
   SyntaxKind,
   VariableStatement,
+  ThisExpression,
+  ArrowFunction,
+  ParenthesizedExpression,
+  PropertyName,
+  SpreadAssignment,
+  ArrayLiteralExpression,
 } from 'typescript';
-import path from 'path';
 
 const iterate = <T>(
   kind: number,
@@ -26,29 +41,54 @@ const iterate = <T>(
   };
 };
 
-const isNode = <T extends { kind: number }>() => {
-  return <U extends T>(kind: number) => {
-    return (node?: T): node is U => {
-      return node?.kind === kind;
-    };
+const isNode = <T extends Expression | ObjectLiteralElement | Node>(
+  kind: number,
+) => {
+  return (node?: Expression | ObjectLiteralElement | Node): node is T => {
+    return node?.kind === kind;
   };
 };
 
-const isExpression = isNode<Expression>();
-const isObjectLiteral = isNode<ObjectLiteralElement>();
-
 export const ts = {
+  getStatements(content: string): NodeArray<Statement> {
+    const { statements } = createSourceFile(
+      'file.ts',
+      content,
+      ScriptTarget.Latest,
+      true,
+    );
+    return statements;
+  },
   is: {
-    call: isExpression<CallExpression>(SyntaxKind.CallExpression),
-    objectLiteral: isExpression<ObjectLiteralExpression>(
+    call: isNode<CallExpression>(SyntaxKind.CallExpression),
+    objectLiteral: isNode<ObjectLiteralExpression>(
       SyntaxKind.ObjectLiteralExpression,
     ),
-    propertyAssignment: isObjectLiteral<PropertyAssignment>(
+    propertyAssignment: isNode<PropertyAssignment>(
       SyntaxKind.PropertyAssignment,
     ),
-    shorthandPropertyAssignment: isObjectLiteral<ShorthandPropertyAssignment>(
+    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),
@@ -110,7 +150,17 @@ export const ts = {
       }
     },
   },
+  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();
@@ -121,12 +171,6 @@ export const ts = {
       }
     },
   },
-  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');

package/src/appCodeUpdater/updateMainFile.test.ts

@@ -1,17 +1,15 @@
 import { updateMainFile } from './updateMainFile';
 import * as path from 'path';
 import * as fs from 'fs/promises';
-import { ast } from './testUtils';
+import { asMock, ast, makeTestWritten, tablePath } 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}`);
+const testWritten = makeTestWritten(mainFilePath);
 
 describe('updateMainFile', () => {
   beforeEach(() => {
@@ -36,17 +34,14 @@ export const db = orchidORM({}, {});
 
       await updateMainFile(mainFilePath, tablePath, ast.addTable);
 
-      expect(fs.writeFile).toBeCalledWith(
-        mainFilePath,
-        `
+      testWritten(`
 import { orchidORM } from 'orchid-orm';
 import { Table } from './tables/table';
 
 export const db = orchidORM({}, {
   table: Table,
 });
-`,
-      );
+`);
     });
 
     it('should handle import as', async () => {
@@ -58,17 +53,14 @@ export const db = custom({}, {});
 
       await updateMainFile(mainFilePath, tablePath, ast.addTable);
 
-      expect(fs.writeFile).toBeCalledWith(
-        mainFilePath,
-        `
+      testWritten(`
 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 () => {
@@ -83,9 +75,7 @@ export const db = orchidORM({}, {
 
       await updateMainFile(mainFilePath, tablePath, ast.addTable);
 
-      expect(fs.writeFile).toBeCalledWith(
-        mainFilePath,
-        `
+      testWritten(`
 import { orchidORM } from 'orchid-orm';
 import { Some } from './tables/some';
 import { Table } from './tables/table';
@@ -94,8 +84,7 @@ export const db = orchidORM({}, {
   some: Some,
   table: Table,
 });
-`,
-      );
+`);
     });
 
     it('should handle object list without ending coma', async () => {
@@ -110,9 +99,7 @@ export const db = orchidORM({}, {
 
       await updateMainFile(mainFilePath, tablePath, ast.addTable);
 
-      expect(fs.writeFile).toBeCalledWith(
-        mainFilePath,
-        `
+      testWritten(`
 import { orchidORM } from 'orchid-orm';
 import { Some } from './tables/some';
 import { Table } from './tables/table';
@@ -121,8 +108,7 @@ export const db = orchidORM({}, {
   some: Some,
   table: Table,
 });
-`,
-      );
+`);
     });
   });
 
@@ -139,15 +125,12 @@ export const db = orchidORM({}, {
 
       await updateMainFile(mainFilePath, tablePath, ast.dropTable);
 
-      expect(fs.writeFile).toBeCalledWith(
-        mainFilePath,
-        `
+      testWritten(`
 import { orchidORM } from 'orchid-orm';
 
 export const db = orchidORM({}, {
 });
-`,
-      );
+`);
     });
 
     it('should remove aliased import', async () => {
@@ -162,15 +145,12 @@ export const db = orchidORM({}, {
 
       await updateMainFile(mainFilePath, tablePath, ast.dropTable);
 
-      expect(fs.writeFile).toBeCalledWith(
-        mainFilePath,
-        `
+      testWritten(`
 import { orchidORM } from 'orchid-orm';
 
 export const db = orchidORM({}, {
 });
-`,
-      );
+`);
     });
 
     it('should remove short form of key and value', async () => {
@@ -185,15 +165,12 @@ export const db = orchidORM({}, {
 
       await updateMainFile(mainFilePath, tablePath, ast.dropTable);
 
-      expect(fs.writeFile).toBeCalledWith(
-        mainFilePath,
-        `
+      testWritten(`
 import { orchidORM } from 'orchid-orm';
 
 export const db = orchidORM({}, {
 });
-`,
-      );
+`);
     });
 
     it('should not remove other tables', async () => {
@@ -212,9 +189,7 @@ export const db = orchidORM({}, {
 
       await updateMainFile(mainFilePath, tablePath, ast.dropTable);
 
-      expect(fs.writeFile).toBeCalledWith(
-        mainFilePath,
-        `
+      testWritten(`
 import { orchidORM } from 'orchid-orm';
 import { One } from './tables/one';
 import { Two } from './tables/two';
@@ -223,8 +198,7 @@ export const db = orchidORM({}, {
   one,
   two,
 });
-`,
-      );
+`);
     });
   });
 });

package/src/appCodeUpdater/updateMainFile.ts

@@ -1,16 +1,11 @@
 import { RakeDbAst } from 'rake-db';
 import fs from 'fs/promises';
-import {
-  createSourceFile,
-  NodeArray,
-  ObjectLiteralExpression,
-  ScriptTarget,
-  Statement,
-} from 'typescript';
+import { NodeArray, ObjectLiteralExpression, Statement } from 'typescript';
 import { toCamelCase, toPascalCase } from '../utils';
 import { AppCodeUpdaterError } from './appCodeUpdater';
 import { FileChanges } from './fileChanges';
 import { ts } from './tsUtils';
+import { getImportPath } from './utils';
 
 type Context = {
   path: string;
@@ -30,13 +25,7 @@ export const updateMainFile = async (
   ast: RakeDbAst,
 ) => {
   const content = await fs.readFile(path, 'utf-8');
-
-  const { statements } = createSourceFile(
-    'file.ts',
-    content,
-    ScriptTarget.Latest,
-    true,
-  );
+  const statements = ts.getStatements(content);
 
   const importName = ts.import.getStatementsImportedName(
     statements,
@@ -86,7 +75,7 @@ const createTable = (
 
   const changes = new FileChanges(content);
 
-  const importPath = ts.path.getRelative(path, tablePath(ast.name));
+  const importPath = getImportPath(path, tablePath(ast.name));
   const importPos = ts.import.getEndPos(statements);
   changes.add(
     importPos,
@@ -111,7 +100,7 @@ const dropTable = (
 ) => {
   const changes = new FileChanges(content);
 
-  const importPath = ts.path.getRelative(path, tablePath(ast.name));
+  const importPath = getImportPath(path, tablePath(ast.name));
   const tableClassName = toPascalCase(ast.name);
   const importNames: string[] = [];
   for (const node of ts.import.iterateWithSource(statements, importPath)) {