rake-db 2.1.18 → 2.2.1

package/CHANGELOG.md

@@ -1,5 +1,23 @@
 # rake-db
 
+## 2.2.1
+
+### Patch Changes
+
+- Updated dependencies
+  - pqb@0.8.1
+
+## 2.2.0
+
+### Minor Changes
+
+- 3f25b4d: Rename all model words to table words, because all models here are not models in OOP meaning
+
+### Patch Changes
+
+- Updated dependencies [3f25b4d]
+  - pqb@0.8.0
+
 ## 2.1.18
 
 ### Patch Changes

package/dist/index.d.ts

@@ -1,55 +1,32 @@
 import * as pqb from 'pqb';
-import { NoPrimaryKeyOption, QueryLogOptions, MaybeArray, AdapterOptions, EmptyObject, RawExpression, ColumnType, ForeignKey, SingleColumnIndexOptions, ColumnTypes, raw, ColumnsShape, IndexColumnOptions, IndexOptions, TransactionAdapter, QueryLogObject, QueryResultRow, QueryInput, TypeParsers, QueryResult, QueryArraysResult, ForeignKeyOptions, TextColumn } from 'pqb';
-
-declare type MigrationConfig = {
-    migrationsPath: string;
-    migrationsTable: string;
-    requireTs(path: string): void;
-    noPrimaryKey?: NoPrimaryKeyOption;
-} & QueryLogOptions;
-
-declare const createDb: (arg: MaybeArray<AdapterOptions>, config: MigrationConfig) => Promise<void>;
-declare const dropDb: (arg: MaybeArray<AdapterOptions>) => Promise<void>;
-declare const resetDb: (arg: MaybeArray<AdapterOptions>, config: MigrationConfig) => Promise<void>;
-
-declare const generate: (config: MigrationConfig, args: string[]) => Promise<void>;
-
-declare const migrate: (options: MaybeArray<AdapterOptions>, config: MigrationConfig, args?: string[]) => Promise<void>;
-declare const rollback: (options: MaybeArray<AdapterOptions>, config: MigrationConfig, args?: string[]) => Promise<void>;
+import { EmptyObject, RawExpression, ColumnType, ColumnTypes, raw, ColumnsShape, TransactionAdapter, QueryLogObject, QueryResultRow, QueryInput, TypeParsers, QueryResult, QueryArraysResult, MaybeArray, IndexColumnOptions, IndexOptions, ForeignKeyOptions, TextColumn, NoPrimaryKeyOption, TableData, SingleColumnIndexOptions, QueryLogOptions, AdapterOptions } from 'pqb';
 
 declare function add(item: ColumnType, options?: {
     dropMode?: DropMode;
-}): ChangeItem;
+}): RakeDbAst.ChangeTableItem.Column;
 declare function add(emptyObject: EmptyObject): EmptyObject;
 declare function add(items: Record<string, ColumnType>, options?: {
     dropMode?: DropMode;
-}): Record<string, ChangeItem>;
+}): Record<string, RakeDbAst.ChangeTableItem.Column>;
+declare type Change = RakeDbAst.ChangeTableItem.Change & ChangeOptions;
 declare type ChangeOptions = {
     usingUp?: RawExpression;
     usingDown?: RawExpression;
 };
-declare type ChangeArg = ColumnType | ['default', unknown | RawExpression] | ['nullable', boolean] | ['comment', string | null] | ['compression', string] | ['primaryKey', boolean] | ['foreignKey', ForeignKey<string, string[]>] | ['index', Omit<SingleColumnIndexOptions, 'column'>];
 declare type TableChangeMethods = typeof tableChangeMethods;
 declare const tableChangeMethods: {
     raw: (sql: string, values?: false | Record<string, unknown> | undefined) => RawExpression<ColumnType<unknown, pqb.Operators, unknown>>;
     add: typeof add;
     drop: typeof add;
-    change(from: ChangeArg, to: ChangeArg, options?: ChangeOptions): ChangeItem;
-    default(value: unknown | RawExpression): ChangeArg;
-    nullable(): ChangeArg;
-    nonNullable(): ChangeArg;
-    comment(name: string | null): ChangeArg;
-    rename(name: string): ChangeItem;
+    change(from: ColumnType | Change, to: ColumnType | Change, options?: ChangeOptions): Change;
+    default(value: unknown | RawExpression): Change;
+    nullable(): Change;
+    nonNullable(): Change;
+    comment(comment: string | null): Change;
+    rename(name: string): RakeDbAst.ChangeTableItem.Rename;
 };
-declare type ChangeItem = [
-    action: 'add' | 'drop',
-    item: ColumnType,
-    options?: {
-        dropMode?: DropMode;
-    }
-] | [action: 'change', from: ChangeArg, to: ChangeArg, options?: ChangeOptions] | ['rename', string];
 declare type TableChanger = MigrationColumnTypes & TableChangeMethods;
-declare type TableChangeData = Record<string, ChangeItem | EmptyObject>;
+declare type TableChangeData = Record<string, RakeDbAst.ChangeTableItem.Column | RakeDbAst.ChangeTableItem.Rename | Change | EmptyObject>;
 
 declare type DropMode = 'CASCADE' | 'RESTRICT';
 declare type TableOptions = {
@@ -69,10 +46,6 @@ declare type ChangeTableOptions = {
     comment?: string | [string, string] | null;
 };
 declare type ChangeTableCallback = (t: TableChanger) => TableChangeData;
-declare type ColumnIndex = {
-    columns: IndexColumnOptions[];
-    options: IndexOptions;
-};
 declare type ColumnComment = {
     column: string;
     comment: string | null;
@@ -89,9 +62,9 @@ declare type ExtensionOptions = {
 };
 declare class Migration extends TransactionAdapter {
     up: boolean;
-    options: MigrationConfig;
+    options: RakeDbConfig;
     log?: QueryLogObject;
-    constructor(tx: TransactionAdapter, up: boolean, options: MigrationConfig);
+    constructor(tx: TransactionAdapter, up: boolean, options: RakeDbConfig);
     query<T extends QueryResultRow = any>(query: QueryInput, types?: TypeParsers, log?: QueryLogObject | undefined): Promise<QueryResult<T>>;
     arrays<R extends any[] = any[]>(query: QueryInput, types?: TypeParsers, log?: QueryLogObject | undefined): Promise<QueryArraysResult<R>>;
     createTable(tableName: string, options: TableOptions, fn: ColumnsShapeCallback): Promise<void>;
@@ -118,23 +91,115 @@ declare class Migration extends TransactionAdapter {
         name?: string;
     }): Promise<void>;
     renameColumn(tableName: string, from: string, to: string): Promise<void>;
-    createSchema(schemaName: string): Promise<QueryResult<any>>;
-    dropSchema(schemaName: string): Promise<QueryResult<any>>;
+    createSchema(schemaName: string): Promise<void>;
+    dropSchema(schemaName: string): Promise<void>;
     createExtension(name: string, options?: ExtensionOptions & {
         ifNotExists?: boolean;
-    }): Promise<QueryResult<any>>;
+    }): Promise<void>;
     dropExtension(name: string, options?: {
         ifExists?: boolean;
         cascade?: boolean;
-    }): Promise<QueryResult<any>>;
+    }): Promise<void>;
     tableExists(tableName: string): Promise<boolean>;
     columnExists(tableName: string, columnName: string): Promise<boolean>;
     constraintExists(constraintName: string): Promise<boolean>;
 }
 
+declare type RakeDbAst = RakeDbAst.Table | RakeDbAst.ChangeTable | RakeDbAst.RenameTable | RakeDbAst.Schema | RakeDbAst.Extension;
+declare namespace RakeDbAst {
+    type Table = {
+        type: 'table';
+        action: 'create' | 'drop';
+        name: string;
+        shape: ColumnsShape;
+        noPrimaryKey: NoPrimaryKeyOption;
+        dropMode?: DropMode;
+        comment?: string;
+    } & TableData;
+    type ChangeTable = {
+        type: 'changeTable';
+        name: string;
+        comment?: string | null;
+        shape: Record<string, ChangeTableItem>;
+        add: TableData;
+        drop: TableData;
+    };
+    type ChangeTableItem = ChangeTableItem.Column | ChangeTableItem.Change | ChangeTableItem.Rename;
+    namespace ChangeTableItem {
+        type Column = {
+            type: 'add' | 'drop';
+            item: ColumnType;
+            dropMode?: DropMode;
+        };
+        type Change = {
+            type: 'change';
+            from: ColumnChange;
+            to: ColumnChange;
+            using?: RawExpression;
+        };
+        type Rename = {
+            type: 'rename';
+            name: string;
+        };
+    }
+    type ColumnChange = {
+        column?: ColumnType;
+        type?: string;
+        collate?: string;
+        default?: unknown | RawExpression;
+        nullable?: boolean;
+        comment?: string | null;
+        compression?: string;
+        primaryKey?: boolean;
+        foreignKey?: {
+            table: string;
+            columns: string[];
+        } & ForeignKeyOptions;
+        index?: Omit<SingleColumnIndexOptions, 'column'>;
+    };
+    type RenameTable = {
+        type: 'renameTable';
+        from: string;
+        to: string;
+    };
+    type Schema = {
+        type: 'schema';
+        action: 'create' | 'drop';
+        name: string;
+    };
+    type Extension = {
+        type: 'extension';
+        action: 'create' | 'drop';
+        name: string;
+        schema?: string;
+        version?: string;
+        cascade?: boolean;
+        ifExists?: boolean;
+        ifNotExists?: boolean;
+    };
+}
+
+declare type RakeDbConfig = {
+    migrationsPath: string;
+    migrationsTable: string;
+    requireTs(path: string): void;
+    noPrimaryKey?: NoPrimaryKeyOption;
+    appCodeUpdater?: AppCodeUpdater;
+} & QueryLogOptions;
+declare type AppCodeUpdater = (ast: RakeDbAst) => Promise<void>;
+
+declare const createDb: (arg: MaybeArray<AdapterOptions>, config: RakeDbConfig) => Promise<void>;
+declare const dropDb: (arg: MaybeArray<AdapterOptions>) => Promise<void>;
+declare const resetDb: (arg: MaybeArray<AdapterOptions>, config: RakeDbConfig) => Promise<void>;
+
+declare const generate: (config: RakeDbConfig, args: string[]) => Promise<void>;
+
+declare const migrate: (options: MaybeArray<AdapterOptions>, config: RakeDbConfig, args?: string[]) => Promise<void>;
+declare const rollback: (options: MaybeArray<AdapterOptions>, config: RakeDbConfig, args?: string[]) => Promise<void>;
+
 declare type ChangeCallback = (db: Migration, up: boolean) => Promise<void>;
 declare const change: (fn: ChangeCallback) => void;
 
-declare const rakeDb: (options: MaybeArray<AdapterOptions>, partialConfig?: Partial<MigrationConfig>, args?: string[]) => Promise<void>;
+declare const rakeDb: (options: MaybeArray<AdapterOptions>, partialConfig?: Partial<RakeDbConfig>, args?: string[]) => Promise<void>;
 
-export { ChangeTableCallback, ChangeTableOptions, ColumnComment, ColumnIndex, ColumnsShapeCallback, DropMode, ExtensionOptions, JoinTableOptions, Migration, MigrationColumnTypes, TableOptions, change, createDb, dropDb, generate, migrate, rakeDb, resetDb, rollback };
+export { AppCodeUpdater, ChangeTableCallback, ChangeTableOptions, ColumnComment, ColumnsShapeCallback, DropMode, ExtensionOptions, JoinTableOptions, Migration, MigrationColumnTypes, RakeDbAst, RakeDbConfig, TableOptions, change, createDb, dropDb, generate, migrate, rakeDb, resetDb, rollback };