orchid-orm 1.3.15 → 1.4.16

package/CHANGELOG.md

@@ -1,5 +1,25 @@
 # orchid-orm
 
+## 2.0.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
+  - rake-db@2.2.0
+
+## 1.3.16
+
+### Patch Changes
+
+- Refactor create and update of relations
+- Updated dependencies
+  - pqb@0.7.13
+
 ## 1.3.15
 
 ### Patch Changes

package/dist/index.d.ts

@@ -1,23 +1,44 @@
-import { BelongsToRelation, HasOneRelation, Db, Adapter, AdapterOptions, QueryLogOptions, NoPrimaryKeyOption, HasManyRelation, HasAndBelongsToManyRelation, Query, defaultsKey, BaseRelation, EmptyObject, RelationQuery, SetQueryReturnsOne, SetQueryReturnsOneOptional, SetQueryReturnsAll, ColumnTypesBase, ColumnsShape, ColumnShapeOutput, WhereResult, MergeQuery, SetQueryReturns, QueryReturnType } from 'pqb';
+import { BelongsToRelation, HasManyRelation, HasOneRelation, Db, Adapter, AdapterOptions, QueryLogOptions, NoPrimaryKeyOption, HasAndBelongsToManyRelation, Query, defaultsKey, EmptyObject, BaseRelation, RelationQuery, SetQueryReturnsOne, SetQueryReturnsOneOptional, SetQueryReturnsAll, ColumnTypesBase, ColumnsShape, ColumnShapeOutput, WhereResult, MergeQuery, SetQueryReturns, QueryReturnType } from 'pqb';
+import { AppCodeUpdater } from 'rake-db';
 
 interface BelongsTo extends RelationThunkBase {
     type: 'belongsTo';
     returns: 'one';
     options: BelongsToRelation['options'];
 }
-declare type BelongsToInfo<T extends Model, Relation extends BelongsTo, FK extends string = Relation['options']['foreignKey']> = {
+declare type BelongsToInfo<T extends Table, Relation extends BelongsTo, FK extends string = Relation['options']['foreignKey']> = {
     params: Record<FK, T['columns']['shape'][FK]['type']>;
     populate: never;
     chainedCreate: false;
     chainedDelete: false;
 };
 
+interface HasMany extends RelationThunkBase {
+    type: 'hasMany';
+    returns: 'many';
+    options: HasManyRelation['options'];
+}
+declare type HasManyInfo<T extends Table, Relations extends RelationThunks, Relation extends HasMany> = {
+    params: Relation['options'] extends {
+        primaryKey: string;
+    } ? Record<Relation['options']['primaryKey'], T['columns']['shape'][Relation['options']['primaryKey']]['type']> : Relation['options'] extends {
+        through: string;
+    } ? RelationInfo<T, Relations, Relations[Relation['options']['through']]>['params'] : never;
+    populate: Relation['options'] extends {
+        foreignKey: string;
+    } ? Relation['options']['foreignKey'] : never;
+    chainedCreate: Relation['options'] extends {
+        primaryKey: string;
+    } ? true : false;
+    chainedDelete: true;
+};
+
 interface HasOne extends RelationThunkBase {
     type: 'hasOne';
     returns: 'one';
     options: HasOneRelation['options'];
 }
-declare type HasOneInfo<T extends Model, Relations extends RelationThunks, Relation extends HasOne> = {
+declare type HasOneInfo<T extends Table, Relations extends RelationThunks, Relation extends HasOne> = {
     params: Relation['options'] extends {
         primaryKey: string;
     } ? Record<Relation['options']['primaryKey'], T['columns']['shape'][Relation['options']['primaryKey']]['type']> : Relation['options'] extends {
@@ -36,47 +57,27 @@ declare function transaction<T extends {
     $queryBuilder: Db;
 }, Result>(this: T, fn: (db: T) => Promise<Result>): Promise<Result>;
 
-declare type OrchidORM<T extends ModelClasses> = {
-    [K in keyof T]: DbModel<T[K]>;
+declare type OrchidORM<T extends TableClasses> = {
+    [K in keyof T]: DbTable<T[K]>;
 } & {
     $transaction: typeof transaction;
     $adapter: Adapter;
     $queryBuilder: Db;
     $close(): Promise<void>;
 };
-declare const orchidORM: <T extends ModelClasses>({ log, logger, autoPreparedStatements, noPrimaryKey, ...options }: (Omit<AdapterOptions, "log"> | {
+declare const orchidORM: <T extends TableClasses>({ log, logger, autoPreparedStatements, noPrimaryKey, ...options }: (Omit<AdapterOptions, "log"> | {
     adapter: Adapter;
 }) & QueryLogOptions & {
     autoPreparedStatements?: boolean | undefined;
     noPrimaryKey?: NoPrimaryKeyOption | undefined;
-}, models: T) => OrchidORM<T>;
-
-interface HasMany extends RelationThunkBase {
-    type: 'hasMany';
-    returns: 'many';
-    options: HasManyRelation['options'];
-}
-declare type HasManyInfo<T extends Model, Relations extends RelationThunks, Relation extends HasMany> = {
-    params: Relation['options'] extends {
-        primaryKey: string;
-    } ? Record<Relation['options']['primaryKey'], T['columns']['shape'][Relation['options']['primaryKey']]['type']> : Relation['options'] extends {
-        through: string;
-    } ? RelationInfo<T, Relations, Relations[Relation['options']['through']]>['params'] : never;
-    populate: Relation['options'] extends {
-        foreignKey: string;
-    } ? Relation['options']['foreignKey'] : never;
-    chainedCreate: Relation['options'] extends {
-        primaryKey: string;
-    } ? true : false;
-    chainedDelete: true;
-};
+}, tables: T) => OrchidORM<T>;
 
 interface HasAndBelongsToMany extends RelationThunkBase {
     type: 'hasAndBelongsToMany';
     returns: 'many';
     options: HasAndBelongsToManyRelation['options'];
 }
-declare type HasAndBelongsToManyInfo<T extends Model, Relation extends HasAndBelongsToMany> = {
+declare type HasAndBelongsToManyInfo<T extends Table, Relation extends HasAndBelongsToMany> = {
     params: Record<Relation['options']['primaryKey'], T['columns']['shape'][Relation['options']['primaryKey']]['type']>;
     populate: never;
     chainedCreate: true;
@@ -86,66 +87,64 @@ declare type HasAndBelongsToManyInfo<T extends Model, Relation extends HasAndBel
 interface RelationThunkBase {
     type: string;
     returns: 'one' | 'many';
-    fn(): ModelClass;
+    fn(): TableClass;
     options: BaseRelation['options'];
 }
 declare type RelationThunk = BelongsTo | HasOne | HasMany | HasAndBelongsToMany;
 declare type RelationThunks = Record<string, RelationThunk>;
-declare type Relation<T extends Model, Relations extends RelationThunks, K extends keyof Relations, M extends Query = DbModel<ReturnType<Relations[K]['fn']>>, Info extends RelationInfo = RelationInfo<T, Relations, Relations[K]>> = {
+declare type Relation<T extends Table, Relations extends RelationThunks, K extends keyof Relations, M extends Query = DbTable<ReturnType<Relations[K]['fn']>>, Info extends RelationInfo = RelationInfo<T, Relations, Relations[K]>> = {
     type: Relations[K]['type'];
     returns: Relations[K]['returns'];
     key: K;
-    model: M;
+    table: M;
     query: M;
     joinQuery(fromQuery: Query, toQuery: Query): Query;
     defaults: Info['populate'];
     nestedCreateQuery: [Info['populate']] extends [never] ? M : M & {
         [defaultsKey]: Record<Info['populate'], true>;
     };
-    nestedInsert: BaseRelation['nestedInsert'];
-    nestedUpdate: BaseRelation['nestedUpdate'];
     primaryKey: string;
     options: Relations[K]['options'];
 };
-declare type RelationScopeOrModel<Relation extends RelationThunkBase> = Relation['options']['scope'] extends (q: Query) => Query ? ReturnType<Relation['options']['scope']> : DbModel<ReturnType<Relation['fn']>>;
-declare type RelationInfo<T extends Model = Model, Relations extends RelationThunks = RelationThunks, Relation extends RelationThunk = RelationThunk> = Relation extends BelongsTo ? BelongsToInfo<T, Relation> : Relation extends HasOne ? HasOneInfo<T, Relations, Relation> : Relation extends HasMany ? HasManyInfo<T, Relations, Relation> : Relation extends HasAndBelongsToMany ? HasAndBelongsToManyInfo<T, Relation> : never;
-declare type MapRelation<T extends Model, Relations extends RelationThunks, RelationName extends keyof Relations, Relation extends RelationThunk = Relations[RelationName], RelatedQuery extends Query = RelationScopeOrModel<Relation>, Info extends {
+declare type RelationScopeOrTable<Relation extends RelationThunkBase> = Relation['options']['scope'] extends (q: Query) => Query ? ReturnType<Relation['options']['scope']> : DbTable<ReturnType<Relation['fn']>>;
+declare type RelationInfo<T extends Table = Table, Relations extends RelationThunks = RelationThunks, Relation extends RelationThunk = RelationThunk> = Relation extends BelongsTo ? BelongsToInfo<T, Relation> : Relation extends HasOne ? HasOneInfo<T, Relations, Relation> : Relation extends HasMany ? HasManyInfo<T, Relations, Relation> : Relation extends HasAndBelongsToMany ? HasAndBelongsToManyInfo<T, Relation> : never;
+declare type MapRelation<T extends Table, Relations extends RelationThunks, RelationName extends keyof Relations, Relation extends RelationThunk = Relations[RelationName], RelatedQuery extends Query = RelationScopeOrTable<Relation>, Info extends {
     params: Record<string, unknown>;
     populate: string;
     chainedCreate: boolean;
     chainedDelete: boolean;
 } = RelationInfo<T, Relations, Relation>> = RelationQuery<RelationName, Info['params'], Info['populate'], Relation['returns'] extends 'one' ? Relation['options']['required'] extends true ? SetQueryReturnsOne<RelatedQuery> : SetQueryReturnsOneOptional<RelatedQuery> : SetQueryReturnsAll<RelatedQuery>, Relation['options']['required'] extends boolean ? Relation['options']['required'] : false, Info['chainedCreate'], Info['chainedDelete']>;
-declare type MapRelations<T extends Model> = 'relations' extends keyof T ? T['relations'] extends RelationThunks ? {
+declare type MapRelations<T extends Table> = 'relations' extends keyof T ? T['relations'] extends RelationThunks ? {
     [K in keyof T['relations']]: MapRelation<T, T['relations'], K>;
 } : EmptyObject : EmptyObject;
 
-declare type ModelClass<T extends Model = Model> = new () => T;
-declare type ModelClasses = Record<string, ModelClass>;
-declare type ModelToDb<T extends Model> = Db<T['table'], T['columns']['shape'], 'relations' extends keyof T ? T['relations'] extends RelationThunks ? {
+declare type TableClass<T extends Table = Table> = new () => T;
+declare type TableClasses = Record<string, TableClass>;
+declare type TableToDb<T extends Table> = Db<T['table'], T['columns']['shape'], 'relations' extends keyof T ? T['relations'] extends RelationThunks ? {
     [K in keyof T['relations']]: Relation<T, T['relations'], K>;
 } : Query['relations'] : Query['relations'], T['columnTypes']> & {
     definedAs: string;
-    db: OrchidORM<ModelClasses>;
+    db: OrchidORM<TableClasses>;
 };
-declare type DbModel<T extends ModelClass> = ModelToDb<InstanceType<T>> & Omit<MapRelations<InstanceType<T>>, keyof Query>;
-declare type ModelConfig = {
+declare type DbTable<T extends TableClass> = TableToDb<InstanceType<T>> & Omit<MapRelations<InstanceType<T>>, keyof Query>;
+declare type TableConfig = {
     shape: ColumnsShape;
     type: unknown;
 };
-declare type ScopeFn<Related extends ModelClass, Scope extends Query> = (q: DbModel<Related>) => Scope;
-declare type Model = {
+declare type ScopeFn<Related extends TableClass, Scope extends Query> = (q: DbTable<Related>) => Scope;
+declare type Table = {
     table: string;
-    columns: ModelConfig;
+    columns: TableConfig;
     schema?: string;
     columnTypes: ColumnTypesBase;
     noPrimaryKey?: boolean;
 };
-declare const createModel: <CT extends ColumnTypesBase>(options: {
+declare const createBaseTable: <CT extends ColumnTypesBase>(options: {
     columnTypes: CT;
 }) => {
     new (): {
         table: string;
-        columns: ModelConfig;
+        columns: TableConfig;
         schema?: string | undefined;
         columnTypes: CT;
         noPrimaryKey?: boolean | undefined;
@@ -153,7 +152,7 @@ declare const createModel: <CT extends ColumnTypesBase>(options: {
             shape: T;
             type: ColumnShapeOutput<T>;
         };
-        belongsTo<Self extends any, Related extends ModelClass<Model>, Scope extends Query, Options extends {
+        belongsTo<Self extends any, Related extends TableClass<Table>, Scope extends Query, Options extends {
             primaryKey: keyof InstanceType<Related>["columns"]["shape"];
             foreignKey: keyof Self["columns"]["shape"];
             scope?: ScopeFn<Related, Scope> | undefined;
@@ -164,7 +163,7 @@ declare const createModel: <CT extends ColumnTypesBase>(options: {
             fn: () => Related;
             options: Options;
         };
-        hasOne<Self_1 extends any, Related_1 extends ModelClass<Model>, Scope_1 extends Query, Through extends string, Source extends string, Options_1 extends ({
+        hasOne<Self_1 extends any, Related_1 extends TableClass<Table>, Scope_1 extends Query, Through extends string, Source extends string, Options_1 extends ({
             primaryKey: keyof Self_1["columns"]["shape"];
             foreignKey: keyof InstanceType<Related_1>["columns"]["shape"];
         } | {
@@ -179,7 +178,7 @@ declare const createModel: <CT extends ColumnTypesBase>(options: {
             fn: () => Related_1;
             options: Options_1;
         };
-        hasMany<Self_2 extends any, Related_2 extends ModelClass<Model>, Scope_2 extends Query, Through_1 extends string, Source_1 extends string, Options_2 extends ({
+        hasMany<Self_2 extends any, Related_2 extends TableClass<Table>, Scope_2 extends Query, Through_1 extends string, Source_1 extends string, Options_2 extends ({
             primaryKey: keyof Self_2["columns"]["shape"];
             foreignKey: keyof InstanceType<Related_2>["columns"]["shape"];
         } | {
@@ -194,7 +193,7 @@ declare const createModel: <CT extends ColumnTypesBase>(options: {
             fn: () => Related_2;
             options: Options_2;
         };
-        hasAndBelongsToMany<Self_3 extends any, Related_3 extends ModelClass<Model>, Scope_3 extends Query, Options_3 extends {
+        hasAndBelongsToMany<Self_3 extends any, Related_3 extends TableClass<Table>, Scope_3 extends Query, Options_3 extends {
             primaryKey: keyof Self_3["columns"]["shape"];
             associationPrimaryKey: keyof InstanceType<Related_3>["columns"]["shape"];
             foreignKey: string;
@@ -228,6 +227,12 @@ declare type Repo<T extends Query, Methods extends MethodsBase<T>, Mapped = MapM
     table: T['table'];
     shape: T['shape'];
 }>(q: Q) => Q & Mapped) & T & Mapped;
-declare const createRepo: <T extends Query, Methods extends MethodsBase<T>>(model: T, methods: Methods) => Repo<T, Methods, MapMethods<T, Methods>>;
+declare const createRepo: <T extends Query, Methods extends MethodsBase<T>>(table: T, methods: Methods) => Repo<T, Methods, MapMethods<T, Methods>>;
+
+declare type AppCodeUpdaterConfig = {
+    tablePath(tableName: string): string;
+    mainFilePath: string;
+};
+declare const appCodeUpdater: () => AppCodeUpdater;
 
-export { DbModel, MapMethods, MapQueryMethods, MethodsBase, Model, ModelClass, ModelClasses, ModelToDb, OrchidORM, QueryMethods, Repo, createModel, createRepo, orchidORM };
+export { AppCodeUpdaterConfig, DbTable, MapMethods, MapQueryMethods, MethodsBase, OrchidORM, QueryMethods, Repo, Table, TableClass, TableClasses, TableToDb, appCodeUpdater, createBaseTable, createRepo, orchidORM };