orchid-orm 1.4.22 → 1.5.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "orchid-orm",
-  "version": "1.4.22",
+  "version": "1.5.1",
   "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.5"
+    "pqb": "0.9.1"
   },
   "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.5",
+    "orchid-orm-schema-to-zod": "0.2.7",
     "@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.6"
+    "rake-db": "2.3.1"
   },
   "peerDependencies": {
     "typescript": "*"

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

@@ -401,6 +401,84 @@ export class Table extends BaseTable {
   });
 
   describe('indexes', () => {
+    it('should change column indexes', async () => {
+      asMock(fs.readFile)
+        .mockResolvedValue(`import { BaseTable } from '../baseTable';
+
+export class Table extends BaseTable {
+  table = 'table';
+  columns = this.setColumns((t) => ({
+    name: t.text().index({ order: 'one' }).index({ collate: 'en_US' })
+  }));
+}`);
+
+      await updateTableFile({
+        ...params,
+        ast: {
+          ...ast.changeTable,
+          shape: {
+            name: {
+              type: 'change',
+              from: { indexes: [{ order: 'one' }, { collate: 'en_US' }] },
+              to: { indexes: [{ order: 'two' }, { collate: 'en_UK' }] },
+            },
+          },
+        },
+      });
+
+      testWritten(`import { BaseTable } from '../baseTable';
+
+export class Table extends BaseTable {
+  table = 'table';
+  columns = this.setColumns((t) => ({
+    name: t.text().index({
+      order: 'two',
+    }).index({
+      collate: 'en_UK',
+    }),
+  }));
+}`);
+    });
+
+    it('should add column indexes', async () => {
+      asMock(fs.readFile)
+        .mockResolvedValue(`import { BaseTable } from '../baseTable';
+
+export class Table extends BaseTable {
+  table = 'table';
+  columns = this.setColumns((t) => ({
+    name: t.text(),
+  }));
+}`);
+
+      await updateTableFile({
+        ...params,
+        ast: {
+          ...ast.changeTable,
+          shape: {
+            name: {
+              type: 'change',
+              from: {},
+              to: { indexes: [{ order: 'two' }, { collate: 'fr_FR' }] },
+            },
+          },
+        },
+      });
+
+      testWritten(`import { BaseTable } from '../baseTable';
+
+export class Table extends BaseTable {
+  table = 'table';
+  columns = this.setColumns((t) => ({
+    name: t.text().index({
+      order: 'two',
+    }).index({
+      collate: 'fr_FR',
+    }),
+  }));
+}`);
+    });
+
     const result = `import { BaseTable } from '../baseTable';
 
 export class Table extends BaseTable {
@@ -413,7 +491,6 @@ export class Table extends BaseTable {
         '9',
         {
           column: '10',
-          expression: 321,
           order: 'new',
         },
       ],
@@ -436,10 +513,7 @@ export class Table extends BaseTable {
           options: {},
         },
         {
-          columns: [
-            { column: '9' },
-            { column: '10', order: 'new', expression: 321 },
-          ],
+          columns: [{ column: '9' }, { column: '10', order: 'new' }],
           options: { name: 'newName' },
         },
       ],
@@ -454,7 +528,7 @@ export class Table extends BaseTable {
   columns = this.setColumns((t) => ({
     ...t.index('1'),
     ...t.index(['2', '3']),
-    ...t.index(['4', { column: '5', order: 'order', expression: 123 }], { name: 'indexName' }),
+    ...t.index(['4', { column: '5', order: 'order' }], { name: 'indexName' }),
   }));
 }`);
 
@@ -474,10 +548,7 @@ export class Table extends BaseTable {
                 options: {},
               },
               {
-                columns: [
-                  { column: '4' },
-                  { column: '5', order: 'order', expression: 123 },
-                ],
+                columns: [{ column: '4' }, { column: '5', order: 'order' }],
                 options: { name: 'indexName' },
               },
             ],
@@ -512,6 +583,91 @@ export class Table extends BaseTable {
   });
 
   describe('foreignKeys', () => {
+    it('should change column foreignKeys', async () => {
+      asMock(fs.readFile)
+        .mockResolvedValue(`import { BaseTable } from '../baseTable';
+
+export class Table extends BaseTable {
+  table = 'table';
+  columns = this.setColumns((t) => ({
+    name: t.text().foreignKey('a', 'b').foreignKey('c', 'd')
+  }));
+}`);
+
+      await updateTableFile({
+        ...params,
+        ast: {
+          ...ast.changeTable,
+          shape: {
+            name: {
+              type: 'change',
+              from: {
+                foreignKeys: [
+                  { table: 'a', columns: ['b'] },
+                  { table: 'c', columns: ['d'] },
+                ],
+              },
+              to: {
+                foreignKeys: [
+                  { table: 'e', columns: ['f'] },
+                  { table: 'g', columns: ['h'] },
+                ],
+              },
+            },
+          },
+        },
+      });
+
+      testWritten(`import { BaseTable } from '../baseTable';
+
+export class Table extends BaseTable {
+  table = 'table';
+  columns = this.setColumns((t) => ({
+    name: t.text().foreignKey('e', 'f').foreignKey('g', 'h'),
+  }));
+}`);
+    });
+
+    it('should add column indexes', async () => {
+      asMock(fs.readFile)
+        .mockResolvedValue(`import { BaseTable } from '../baseTable';
+
+export class Table extends BaseTable {
+  table = 'table';
+  columns = this.setColumns((t) => ({
+    name: t.text(),
+  }));
+}`);
+
+      await updateTableFile({
+        ...params,
+        ast: {
+          ...ast.changeTable,
+          shape: {
+            name: {
+              type: 'change',
+              from: {},
+              to: {
+                foreignKeys: [
+                  { table: 'e', columns: ['f'] },
+                  { table: 'g', columns: ['h'] },
+                ],
+              },
+            },
+          },
+        },
+      });
+
+      testWritten(`import { BaseTable } from '../baseTable';
+
+export class Table extends BaseTable {
+  table = 'table';
+  columns = this.setColumns((t) => ({
+    name: t.text().foreignKey('e', 'f').foreignKey('g', 'h'),
+  }));
+}`);
+    });
+
     const result = `import { BaseTable } from '../baseTable';
 
 export class Table extends BaseTable {

package/src/codegen/updateTableFile/changeTable.ts

@@ -17,8 +17,12 @@ import {
   Code,
   codeToString,
   columnDefaultArgumentToCode,
+  columnForeignKeysToCode,
+  columnIndexesToCode,
   ColumnType,
+  ForeignKey,
   foreignKeyToCode,
+  IndexColumnOptions,
   indexToCode,
   primaryKeyToCode,
   quoteObjectKey,
@@ -266,20 +270,32 @@ const changeColumn = (
   }
 
   const changedProps: Partial<Record<Key, true>> = {};
+  const replaced: Record<string, true> = {};
   for (const item of items.reverse()) {
     if (!ts.is.propertyAccess(item.expression)) continue;
 
     const { name } = item.expression;
-    const key = name.escapedText.toString();
+    let key = name.escapedText.toString();
+    if (key === 'index') key = 'indexes';
+    else if (key === 'foreignKey') key = 'foreignKeys';
+
     if (!propsToChange[key as Key]) continue;
 
-    const value = getColumnMethodArgs(to, key as Key);
-    if (value) {
-      const code = [`${key}(`];
-      addCode(code, value);
-      addCode(code, ')');
-      changes.replace(name.pos, item.end, codeToString(code, '', '  ').trim());
-    } else {
+    let remove = true;
+    if (!replaced[key]) {
+      const code = getColumnMethodArgs(to, key as Key);
+      if (code) {
+        changes.replace(
+          item.expression.expression.end,
+          item.end,
+          codeToString(code, spaces + '  ', '  ').trim(),
+        );
+        replaced[key] = true;
+        remove = false;
+      }
+    }
+
+    if (remove) {
       changes.remove(item.expression.expression.end, item.end);
     }
 
@@ -290,12 +306,9 @@ const changeColumn = (
   for (const key in propsToChange) {
     if (changedProps[key as Key]) continue;
 
-    const value = getColumnMethodArgs(to, key as Key);
-    if (value !== undefined) {
-      const code = [`.${key}(`];
-      addCode(code, value);
-      addCode(code, ')');
-      append += codeToString(code, '', '  ').trim();
+    const code = getColumnMethodArgs(to, key as Key);
+    if (code) {
+      append += codeToString(code, spaces + '  ', '  ').trim();
     }
   }
 
@@ -350,19 +363,30 @@ const addTableData = ({ add, changes, object, t, spaces }: ChangeContext) => {
 const getColumnMethodArgs = (
   to: RakeDbAst.ChangeTableItem.Change['to'],
   key: keyof RakeDbAst.ChangeTableItem.Change['to'],
-): Code | undefined => {
+): Code[] | undefined => {
   const value = to[key];
   if (!value) return;
 
+  if (key === 'indexes') {
+    return columnIndexesToCode(value as IndexColumnOptions[]);
+  }
+
+  if (key === 'foreignKeys') {
+    return columnForeignKeysToCode(value as ForeignKey<string, string[]>[]);
+  }
+
+  const code = [`.${key}(`];
+
   if (key === 'collate' || key === 'compression') {
-    return singleQuote(value as string);
+    addCode(code, singleQuote(value as string));
   } else if (key === 'default') {
-    return columnDefaultArgumentToCode(value);
-  } else if (key === 'nullable' || key === 'primaryKey') {
-    return '';
-  } else {
+    addCode(code, columnDefaultArgumentToCode(value));
+  } else if (key !== 'nullable' && key !== 'primaryKey') {
     return;
   }
+
+  addCode(code, ')');
+  return code;
 };
 
 const dropMatchingIndexes = (