orchid-orm 1.4.20 → 1.4.21

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "orchid-orm",
-  "version": "1.4.20",
+  "version": "1.4.21",
   "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.3"
+    "pqb": "0.8.4"
   },
   "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.3",
+    "orchid-orm-schema-to-zod": "0.2.4",
     "@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.3"
+    "rake-db": "2.2.4"
   },
   "peerDependencies": {
     "typescript": "*"

package/src/{appCodeUpdater → codegen}/appCodeUpdater.test.ts

@@ -3,6 +3,7 @@ import { asMock, ast } from './testUtils';
 import { updateMainFile } from './updateMainFile';
 import * as path from 'path';
 import { updateTableFile } from './updateTableFile/updateTableFile';
+import { createBaseTableFile } from './createBaseTableFile';
 
 jest.mock('./updateMainFile', () => ({
   updateMainFile: jest.fn(),
@@ -12,18 +13,24 @@ jest.mock('./updateTableFile/updateTableFile', () => ({
   updateTableFile: jest.fn(),
 }));
 
+jest.mock('./createBaseTableFile', () => ({
+  createBaseTableFile: jest.fn(() => Promise.resolve()),
+}));
+
 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',
-    };
+  beforeEach(jest.clearAllMocks);
 
-    const fn = appCodeUpdater(params);
+  const params = {
+    tablePath: (table: string) => `tables/${table}.ts`,
+    baseTablePath: 'baseTable.ts',
+    baseTableName: 'BaseTable',
+    mainFilePath: 'db.ts',
+  };
 
-    await fn(ast.addTable);
+  const fn = appCodeUpdater(params);
+
+  it('should call table and file updaters with proper arguments', async () => {
+    await fn({ ast: ast.addTable, options: {}, cache: {} });
 
     const mainFilePath = path.resolve(params.mainFilePath);
     const tablePath = path.resolve(params.tablePath('table'));
@@ -38,5 +45,22 @@ describe('appCodeUpdater', () => {
     expect(table.baseTablePath).toBe(params.baseTablePath);
     expect(table.baseTableName).toBe(params.baseTableName);
     expect(table.mainFilePath).toBe(mainFilePath);
+
+    const [base] = asMock(createBaseTableFile).mock.calls[0];
+    expect(base.baseTablePath).toBe(params.baseTablePath);
+    expect(base.baseTableName).toBe(params.baseTableName);
+  });
+
+  it('should call createBaseTable only on first call', async () => {
+    const cache = {};
+    expect(createBaseTableFile).not.toBeCalled();
+
+    await fn({ ast: ast.addTable, options: {}, cache });
+
+    expect(createBaseTableFile).toBeCalledTimes(1);
+
+    await fn({ ast: ast.addTable, options: {}, cache });
+
+    expect(createBaseTableFile).toBeCalledTimes(1);
   });
 });

package/src/{appCodeUpdater → codegen}/appCodeUpdater.ts

@@ -2,6 +2,7 @@ import { AppCodeUpdater } from 'rake-db';
 import * as path from 'path';
 import { updateMainFile } from './updateMainFile';
 import { updateTableFile } from './updateTableFile/updateTableFile';
+import { createBaseTableFile } from './createBaseTableFile';
 
 export class AppCodeUpdaterError extends Error {}
 
@@ -21,10 +22,21 @@ export const appCodeUpdater = (
     mainFilePath: path.resolve(config.mainFilePath),
   };
 
-  return async (ast) => {
-    await Promise.all([
-      updateMainFile(params.mainFilePath, params.tablePath, ast),
+  return async ({ ast, options, cache: cacheObject }) => {
+    const promises: Promise<void>[] = [
+      updateMainFile(params.mainFilePath, params.tablePath, ast, options),
       updateTableFile({ ...params, ast }),
-    ]);
+    ];
+
+    const cache = cacheObject as { createdBaseTable?: true };
+    if (!cache.createdBaseTable) {
+      promises.push(
+        createBaseTableFile(params).then(() => {
+          cache.createdBaseTable = true;
+        }),
+      );
+    }
+
+    await Promise.all(promises);
   };
 };

package/src/codegen/createBaseTableFile.test.ts

@@ -0,0 +1,58 @@
+import path from 'path';
+import { createBaseTableFile } from './createBaseTableFile';
+import fs from 'fs/promises';
+import { asMock } from './testUtils';
+
+jest.mock('fs/promises', () => ({
+  mkdir: jest.fn(),
+  writeFile: jest.fn(),
+}));
+
+const params = {
+  baseTablePath: path.resolve('baseTable.ts'),
+  baseTableName: 'CustomName',
+};
+
+describe('createBaseTableFile', () => {
+  it('should call mkdir with recursive option', async () => {
+    asMock(fs.writeFile).mockResolvedValue(null);
+
+    await createBaseTableFile(params);
+
+    expect(fs.mkdir).toBeCalledWith(path.dirname(params.baseTablePath), {
+      recursive: true,
+    });
+  });
+
+  it('should write file with wx flag to not overwrite', async () => {
+    asMock(fs.writeFile).mockRejectedValueOnce(
+      Object.assign(new Error(), { code: 'EEXIST' }),
+    );
+
+    await createBaseTableFile(params);
+
+    expect(asMock(fs.writeFile)).toBeCalledWith(
+      params.baseTablePath,
+      `import { createBaseTable } from 'orchid-orm';
+import { columnTypes } from 'pqb';
+
+export const ${params.baseTableName} = createBaseTable({
+  columnTypes: {
+    ...columnTypes,
+  },
+});
+`,
+      {
+        flag: 'wx',
+      },
+    );
+  });
+
+  it('should throw if error is not EEXIST', async () => {
+    asMock(fs.writeFile).mockRejectedValueOnce(
+      Object.assign(new Error('custom'), { code: 'other' }),
+    );
+
+    await expect(() => createBaseTableFile(params)).rejects.toThrow('custom');
+  });
+});

package/src/codegen/createBaseTableFile.ts

@@ -0,0 +1,36 @@
+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';
+import { columnTypes } from 'pqb';
+
+export const ${baseTableName} = createBaseTable({
+  columnTypes: {
+    ...columnTypes,
+  },
+});
+`,
+      {
+        flag: 'wx',
+      },
+    )
+    .catch((err) => {
+      if (err.code === 'EEXIST') return;
+      throw err;
+    });
+};

package/src/{appCodeUpdater → codegen}/updateMainFile.test.ts

@@ -6,25 +6,44 @@ 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();
   });
 
-  it('should throw when file is not found', async () => {
-    asMock(fs.readFile).mockRejectedValue(new Error());
+  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 expect(() =>
-      updateMainFile(mainFilePath, tablePath, ast.addTable),
-    ).rejects.toThrow();
-  });
+      await updateMainFile(mainFilePath, tablePath, ast.addTable, options);
+
+      expect(asMock(fs.mkdir)).toBeCalledWith(path.dirname(mainFilePath), {
+        recursive: true,
+      });
+
+      testWritten(`import { orchidORM } from 'orchid-orm';
+import { Table } from './tables/table';
+
+export const db = orchidORM(
+  {
+    databaseURL: 'url',
+  },
+  {
+    table: Table,
+  }
+);
+`);
+    });
 
-  describe('add table', () => {
     it('should add table', async () => {
       asMock(fs.readFile).mockResolvedValue(`
 import { orchidORM } from 'orchid-orm';
@@ -32,7 +51,7 @@ import { orchidORM } from 'orchid-orm';
 export const db = orchidORM({}, {});
 `);
 
-      await updateMainFile(mainFilePath, tablePath, ast.addTable);
+      await updateMainFile(mainFilePath, tablePath, ast.addTable, options);
 
       testWritten(`
 import { orchidORM } from 'orchid-orm';
@@ -51,7 +70,7 @@ import { orchidORM as custom } from 'orchid-orm';
 export const db = custom({}, {});
 `);
 
-      await updateMainFile(mainFilePath, tablePath, ast.addTable);
+      await updateMainFile(mainFilePath, tablePath, ast.addTable, options);
 
       testWritten(`
 import { orchidORM as custom } from 'orchid-orm';
@@ -73,7 +92,7 @@ export const db = orchidORM({}, {
 });
 `);
 
-      await updateMainFile(mainFilePath, tablePath, ast.addTable);
+      await updateMainFile(mainFilePath, tablePath, ast.addTable, options);
 
       testWritten(`
 import { orchidORM } from 'orchid-orm';
@@ -97,7 +116,7 @@ export const db = orchidORM({}, {
 });
 `);
 
-      await updateMainFile(mainFilePath, tablePath, ast.addTable);
+      await updateMainFile(mainFilePath, tablePath, ast.addTable, options);
 
       testWritten(`
 import { orchidORM } from 'orchid-orm';
@@ -123,7 +142,7 @@ export const db = orchidORM({}, {
 });
 `);
 
-      await updateMainFile(mainFilePath, tablePath, ast.dropTable);
+      await updateMainFile(mainFilePath, tablePath, ast.dropTable, options);
 
       testWritten(`
 import { orchidORM } from 'orchid-orm';
@@ -143,7 +162,7 @@ export const db = orchidORM({}, {
 });
 `);
 
-      await updateMainFile(mainFilePath, tablePath, ast.dropTable);
+      await updateMainFile(mainFilePath, tablePath, ast.dropTable, options);
 
       testWritten(`
 import { orchidORM } from 'orchid-orm';
@@ -163,7 +182,7 @@ export const db = orchidORM({}, {
 });
 `);
 
-      await updateMainFile(mainFilePath, tablePath, ast.dropTable);
+      await updateMainFile(mainFilePath, tablePath, ast.dropTable, options);
 
       testWritten(`
 import { orchidORM } from 'orchid-orm';
@@ -187,7 +206,7 @@ export const db = orchidORM({}, {
 });
 `);
 
-      await updateMainFile(mainFilePath, tablePath, ast.dropTable);
+      await updateMainFile(mainFilePath, tablePath, ast.dropTable, options);
 
       testWritten(`
 import { orchidORM } from 'orchid-orm';

package/src/{appCodeUpdater → codegen}/updateMainFile.ts

@@ -1,14 +1,16 @@
 import { RakeDbAst } from 'rake-db';
 import fs from 'fs/promises';
+import path from 'path';
 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';
+import { AdapterOptions, singleQuote } from 'pqb';
 
 type Context = {
-  path: string;
+  filePath: string;
   tablePath: (name: string) => string;
   statements: NodeArray<Statement>;
   object: ObjectLiteralExpression;
@@ -19,12 +21,48 @@ type Context = {
 const libraryName = 'orchid-orm';
 const importKey = 'orchidORM';
 
+const newFile = (
+  options: AdapterOptions,
+) => `import { orchidORM } from 'orchid-orm';
+
+export const db = orchidORM(
+  {
+    ${optionsToString(options)}
+  },
+  {
+  }
+);
+`;
+
+const optionsToString = (options: AdapterOptions) => {
+  const lines: string[] = [];
+  for (const key in options) {
+    const value = options[key as keyof AdapterOptions];
+    if (typeof value !== 'object' && typeof value !== 'function') {
+      lines.push(
+        `${key}: ${typeof value === 'string' ? singleQuote(value) : value},`,
+      );
+    }
+  }
+  return lines.join('\n    ');
+};
+
 export const updateMainFile = async (
-  path: string,
+  filePath: string,
   tablePath: (name: string) => string,
   ast: RakeDbAst,
+  options: AdapterOptions,
 ) => {
-  const content = await fs.readFile(path, 'utf-8');
+  const result = await fs.readFile(filePath, 'utf-8').then(
+    (content) => ({ error: undefined, content }),
+    (error) => {
+      return { error, content: undefined };
+    },
+  );
+
+  if (result.error && result.error.code !== 'ENOENT') throw result.error;
+  const content = result.content || newFile(options);
+
   const statements = ts.getStatements(content);
 
   const importName = ts.import.getStatementsImportedName(
@@ -46,7 +84,7 @@ export const updateMainFile = async (
   const spaces = ts.spaces.getAtLine(content, object.end);
 
   const context: Context = {
-    path,
+    filePath,
     tablePath,
     statements,
     object,
@@ -54,20 +92,28 @@ export const updateMainFile = async (
     spaces,
   };
 
+  let write: string | undefined;
   if (ast.type === 'table') {
     if (ast.action === 'create') {
-      return fs.writeFile(path, createTable(context, ast));
+      write = createTable(context, ast);
     } else {
-      return fs.writeFile(path, dropTable(context, ast));
+      write = 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
+
+  if (write) {
+    if (result.error) {
+      await fs.mkdir(path.dirname(filePath), { recursive: true });
+    }
+
+    await fs.writeFile(filePath, write);
+  }
 };
 
 const createTable = (
-  { path, tablePath, statements, object, content, spaces }: Context,
+  { filePath, tablePath, statements, object, content, spaces }: Context,
   ast: RakeDbAst.Table,
 ) => {
   const key = toCamelCase(ast.name);
@@ -75,7 +121,7 @@ const createTable = (
 
   const changes = new FileChanges(content);
 
-  const importPath = getImportPath(path, tablePath(ast.name));
+  const importPath = getImportPath(filePath, tablePath(ast.name));
   const importPos = ts.import.getEndPos(statements);
   changes.add(
     importPos,
@@ -95,12 +141,12 @@ const createTable = (
 };
 
 const dropTable = (
-  { path, tablePath, statements, object, content }: Context,
+  { filePath, tablePath, statements, object, content }: Context,
   ast: RakeDbAst.Table,
 ) => {
   const changes = new FileChanges(content);
 
-  const importPath = getImportPath(path, tablePath(ast.name));
+  const importPath = getImportPath(filePath, tablePath(ast.name));
   const tableClassName = toPascalCase(ast.name);
   const importNames: string[] = [];
   for (const node of ts.import.iterateWithSource(statements, importPath)) {

package/src/{appCodeUpdater → codegen}/updateTableFile/changeTable.test.ts

@@ -6,6 +6,7 @@ import { columnTypes, newTableData, TableData } from 'pqb';
 import { RakeDbAst } from 'rake-db';
 
 jest.mock('fs/promises', () => ({
+  mkdir: jest.fn(),
   readFile: jest.fn(),
   writeFile: jest.fn(),
 }));

package/src/{appCodeUpdater → codegen}/updateTableFile/createTable.test.ts

@@ -1,10 +1,12 @@
 import { updateTableFile } from './updateTableFile';
-import { ast, makeTestWritten, tablePath } from '../testUtils';
+import { asMock, ast, makeTestWritten, tablePath } from '../testUtils';
 import path from 'path';
+import fs from 'fs/promises';
 
 jest.mock('fs/promises', () => ({
   readFile: jest.fn(),
   writeFile: jest.fn(),
+  mkdir: jest.fn(),
 }));
 
 const baseTablePath = path.resolve('baseTable.ts');
@@ -44,6 +46,10 @@ describe('createTable', () => {
       },
     });
 
+    expect(asMock(fs.mkdir)).toBeCalledWith(path.dirname(tablePath('table')), {
+      recursive: true,
+    });
+
     testWritten(`import { BaseTable } from '../baseTable';
 
 export class Table extends BaseTable {
@@ -64,7 +70,8 @@ export class Table extends BaseTable {
       },
     ),
   }));
-}`);
+}
+`);
   });
 
   it('should add noPrimaryKey prop when noPrimaryKey is `ignore` in ast', async () => {
@@ -81,6 +88,7 @@ export class Table extends BaseTable {
   columns = this.setColumns((t) => ({
     id: t.serial().primaryKey(),
   }));
-}`);
+}
+`);
   });
 });

package/src/{appCodeUpdater → codegen}/updateTableFile/createTable.ts

@@ -4,6 +4,7 @@ import { Code, codeToString, columnsShapeToCode, singleQuote } from 'pqb';
 import { toPascalCase } from '../../utils';
 import fs from 'fs/promises';
 import { UpdateTableFileParams } from './updateTableFile';
+import path from 'path';
 
 export const createTable = async ({
   ast,
@@ -27,8 +28,9 @@ export const createTable = async ({
     `import { ${params.baseTableName} } from '${baseTablePath}';\n`,
     `export class ${toPascalCase(ast.name)} extends ${params.baseTableName} {`,
     props,
-    '}',
+    '}\n',
   ];
 
+  await fs.mkdir(path.dirname(tablePath), { recursive: true });
   await fs.writeFile(tablePath, codeToString(code, '', '  '));
 };

package/src/{appCodeUpdater → codegen}/updateTableFile/renameTable.test.ts

@@ -4,6 +4,7 @@ import path from 'path';
 import fs from 'fs/promises';
 
 jest.mock('fs/promises', () => ({
+  mkdir: jest.fn(),
   readFile: jest.fn(),
   writeFile: jest.fn(),
 }));

package/src/index.ts

@@ -1,4 +1,4 @@
 export * from './table';
 export * from './orm';
 export * from './repo';
-export * from './appCodeUpdater/appCodeUpdater';
+export * from './codegen/appCodeUpdater';