rake-db 2.12.6 → 2.13.0

package/dist/index.d.ts

@@ -1,10 +1,10 @@
 import * as pqb from 'pqb';
-import { ColumnsShape, Db as Db$1, ColumnType, EnumColumn, raw, Adapter, DbResult, TransactionAdapter, QueryLogObject, IndexColumnOptions, IndexOptions, ForeignKeyOptions, TextColumn, NoPrimaryKeyOption, TableData, SingleColumnIndexOptions, DefaultColumnTypes, AdapterOptions, QueryLogOptions } from 'pqb';
+import { ColumnsShape, Db as Db$1, ColumnType, EnumColumn, raw, Adapter, DbResult, TransactionAdapter, QueryLogObject, IndexColumnOptions, IndexOptions, ForeignKeyOptions, TextColumn, TableData, NoPrimaryKeyOption, SingleColumnIndexOptions, DefaultColumnTypes, QueryLogOptions, AdapterOptions } from 'pqb';
 import { EmptyObject, RawSQLBase, ColumnSchemaConfig, MaybeArray, ColumnTypeBase } from 'orchid-core';
 
-type CreateTableResult<Table extends string, Shape extends ColumnsShape> = {
+interface CreateTableResult<Table extends string, Shape extends ColumnsShape> {
     table: Db$1<Table, Shape>;
-};
+}
 
 declare function add(item: ColumnType, options?: {
     dropMode?: DropMode;
@@ -786,7 +786,7 @@ declare class Migration<CT extends RakeDbColumnTypes> {
 
 type RakeDbAst = RakeDbAst.Table | RakeDbAst.ChangeTable | RakeDbAst.RenameTable | RakeDbAst.Schema | RakeDbAst.Extension | RakeDbAst.Enum | RakeDbAst.Domain | RakeDbAst.Collation | RakeDbAst.Constraint | RakeDbAst.View;
 declare namespace RakeDbAst {
-    type Table = {
+    interface Table extends TableData {
         type: 'table';
         action: 'create' | 'drop';
         schema?: string;
@@ -797,8 +797,8 @@ declare namespace RakeDbAst {
         dropIfExists?: boolean;
         dropMode?: DropMode;
         comment?: string;
-    } & TableData;
-    type ChangeTable = {
+    }
+    interface ChangeTable {
         type: 'changeTable';
         schema?: string;
         name: string;
@@ -806,27 +806,27 @@ declare namespace RakeDbAst {
         shape: Record<string, ChangeTableItem>;
         add: TableData;
         drop: TableData;
-    };
+    }
     type ChangeTableItem = ChangeTableItem.Column | ChangeTableItem.Change | ChangeTableItem.Rename;
     namespace ChangeTableItem {
-        type Column = {
+        interface Column {
             type: 'add' | 'drop';
             item: ColumnType;
             dropMode?: DropMode;
-        };
-        type Change = {
+        }
+        interface Change {
             type: 'change';
             name?: string;
             from: ColumnChange;
             to: ColumnChange;
             using?: RawSQLBase;
-        };
-        type Rename = {
+        }
+        interface Rename {
             type: 'rename';
             name: string;
-        };
+        }
     }
-    type ColumnChange = {
+    interface ColumnChange {
         column?: ColumnType;
         type?: string;
         collate?: string;
@@ -842,20 +842,20 @@ declare namespace RakeDbAst {
         } & ForeignKeyOptions)[];
         indexes?: Omit<SingleColumnIndexOptions, 'column' | 'expression'>[];
         identity?: TableData.Identity;
-    };
-    type RenameTable = {
+    }
+    interface RenameTable {
         type: 'renameTable';
         fromSchema?: string;
         from: string;
         toSchema?: string;
         to: string;
-    };
-    type Schema = {
+    }
+    interface Schema {
         type: 'schema';
         action: 'create' | 'drop';
         name: string;
-    };
-    type Extension = {
+    }
+    interface Extension {
         type: 'extension';
         action: 'create' | 'drop';
         name: string;
@@ -864,8 +864,8 @@ declare namespace RakeDbAst {
         cascade?: boolean;
         createIfNotExists?: boolean;
         dropIfExists?: boolean;
-    };
-    type Enum = {
+    }
+    interface Enum {
         type: 'enum';
         action: 'create' | 'drop';
         schema?: string;
@@ -873,8 +873,8 @@ declare namespace RakeDbAst {
         values: [string, ...string[]];
         cascade?: boolean;
         dropIfExists?: boolean;
-    };
-    type Domain = {
+    }
+    interface Domain {
         type: 'domain';
         action: 'create' | 'drop';
         schema?: string;
@@ -885,8 +885,8 @@ declare namespace RakeDbAst {
         default?: RawSQLBase;
         check?: RawSQLBase;
         cascade?: boolean;
-    };
-    type Collation = {
+    }
+    interface Collation {
         type: 'collation';
         action: 'create' | 'drop';
         schema?: string;
@@ -901,18 +901,18 @@ declare namespace RakeDbAst {
         createIfNotExists?: boolean;
         dropIfExists?: boolean;
         cascade?: boolean;
-    };
-    type EnumOptions = {
+    }
+    interface EnumOptions {
         createIfNotExists?: boolean;
         dropIfExists?: boolean;
-    };
-    type Constraint = {
+    }
+    interface Constraint extends TableData.Constraint {
         type: 'constraint';
         action: 'create';
         tableSchema?: string;
         tableName: string;
-    } & TableData.Constraint;
-    type View = {
+    }
+    interface View {
         type: 'view';
         action: 'create' | 'drop';
         schema?: string;
@@ -920,8 +920,8 @@ declare namespace RakeDbAst {
         shape: ColumnsShape;
         sql: RawSQLBase;
         options: ViewOptions;
-    };
-    type ViewOptions = {
+    }
+    interface ViewOptions {
         createOrReplace?: boolean;
         dropIfExists?: boolean;
         dropMode?: DropMode;
@@ -933,10 +933,10 @@ declare namespace RakeDbAst {
             securityBarrier?: boolean;
             securityInvoker?: boolean;
         };
-    };
+    }
 }
 
-type RakeDbColumnTypes = {
+interface RakeDbColumnTypes {
     index(columns: MaybeArray<string | IndexColumnOptions>, options?: IndexOptions): EmptyObject;
     foreignKey(columns: [string, ...string[]], foreignTable: string, foreignColumns: [string, ...string[]], options?: ForeignKeyOptions): EmptyObject;
     primaryKey(columns: string[], options?: {
@@ -944,8 +944,8 @@ type RakeDbColumnTypes = {
     }): EmptyObject;
     check(check: RawSQLBase): EmptyObject;
     constraint(arg: ConstraintArg): EmptyObject;
-};
-type ConstraintArg = {
+}
+interface ConstraintArg {
     name?: string;
     references?: [
         columns: [string, ...string[]],
@@ -955,9 +955,9 @@ type ConstraintArg = {
     ];
     check?: RawSQLBase;
     dropMode?: DropMode;
-};
+}
 type Db = DbResult<RakeDbColumnTypes>;
-type BaseTable<CT> = {
+interface BaseTable<CT> {
     exportAs: string;
     getFilePath(): string;
     nowSQL?: string;
@@ -966,13 +966,13 @@ type BaseTable<CT> = {
         snakeCase?: boolean;
         language?: string;
     };
-};
+}
 type InputRakeDbConfig<SchemaConfig extends ColumnSchemaConfig, CT> = Partial<Omit<RakeDbConfig<SchemaConfig, CT>, 'columnTypes'>> & ({
     columnTypes?: CT | ((t: DefaultColumnTypes<ColumnSchemaConfig>) => CT);
 } | {
     baseTable?: BaseTable<CT>;
 });
-type RakeDbConfig<SchemaConfig extends ColumnSchemaConfig, CT = DefaultColumnTypes<ColumnSchemaConfig>> = {
+interface RakeDbConfig<SchemaConfig extends ColumnSchemaConfig, CT = DefaultColumnTypes<ColumnSchemaConfig>> extends QueryLogOptions {
     schemaConfig: SchemaConfig;
     columnTypes: CT;
     basePath: string;
@@ -994,9 +994,11 @@ type RakeDbConfig<SchemaConfig extends ColumnSchemaConfig, CT = DefaultColumnTyp
     afterMigrate?(db: Db): Promise<void>;
     beforeRollback?(db: Db): Promise<void>;
     afterRollback?(db: Db): Promise<void>;
-} & QueryLogOptions;
-type ModuleExportsRecord = Record<string, () => Promise<unknown>>;
-type AppCodeUpdaterParams = {
+}
+interface ModuleExportsRecord {
+    [K: string]: () => Promise<unknown>;
+}
+interface AppCodeUpdaterParams {
     options: AdapterOptions;
     basePath: string;
     cache: object;
@@ -1006,14 +1008,14 @@ type AppCodeUpdaterParams = {
         exportAs: string;
     };
     import(path: string): Promise<unknown>;
-};
-type AppCodeUpdater = {
+}
+interface AppCodeUpdater {
     process(params: AppCodeUpdaterParams & {
         ast: RakeDbAst;
     }): Promise<void>;
     afterAll(params: AppCodeUpdaterParams): Promise<void>;
-};
-type MigrationItem = {
+}
+interface MigrationItem {
     path: string;
     version: string;
     /**
@@ -1022,7 +1024,7 @@ type MigrationItem = {
      * Promise can return `{ default: x }` where `x` is a return of `change` or an array of such returns.
      */
     load(): Promise<unknown>;
-};
+}
 
 declare const createDb: <SchemaConfig extends ColumnSchemaConfig, CT>(arg: MaybeArray<AdapterOptions>, config: RakeDbConfig<SchemaConfig, CT>) => Promise<void>;
 declare const dropDb: <SchemaConfig extends ColumnSchemaConfig, CT>(arg: MaybeArray<AdapterOptions>, config: RakeDbConfig<SchemaConfig, CT>) => Promise<void>;

package/dist/index.js

@@ -3249,15 +3249,12 @@ const pushTableAst = (ctx, ast, data, domains, table, pendingTables, innerConstr
     },
     []
   );
-  const columnChecks = innerConstraints.reduce(
-    (acc, item) => {
-      if (belongsToTable(item) && isColumnCheck(item)) {
-        acc[item.check.columns[0]] = item.check.expression;
-      }
-      return acc;
-    },
-    {}
-  );
+  const columnChecks = innerConstraints.reduce((acc, item) => {
+    if (belongsToTable(item) && isColumnCheck(item)) {
+      acc[item.check.columns[0]] = item.check.expression;
+    }
+    return acc;
+  }, {});
   const shape = makeColumnsShape(
     ctx,
     data,