@sqb/connect 4.10.0 → 4.10.2

package/types/orm/repository.class.d.ts

@@ -0,0 +1,140 @@
+import { StrictOmit, Type } from 'ts-gems';
+import { FieldInfoMap } from '../client/field-info-map.js';
+import { SqbClient } from '../client/sqb-client.js';
+import { SqbConnection } from '../client/sqb-connection.js';
+import { QueryRequest, TransactionFunction } from '../client/types.js';
+import { EntityInput, EntityOutput } from '../types.js';
+import { EntityMetadata } from './model/entity-metadata.js';
+interface Projection {
+    pick?: string[];
+    omit?: string[];
+    include?: string[];
+}
+interface Filtering {
+    filter?: any;
+    params?: any;
+}
+export declare namespace Repository {
+    type TransformRowFunction = (fields: FieldInfoMap, row: object, obj: object) => void;
+    interface CommandOptions {
+        connection?: SqbConnection;
+    }
+    interface CreateOptions extends CommandOptions, Projection {
+    }
+    interface CountOptions extends CommandOptions, Filtering {
+    }
+    interface ExistsOptions extends CommandOptions, Filtering {
+    }
+    interface DeleteOptions extends CommandOptions, Filtering {
+    }
+    interface DeleteManyOptions extends CommandOptions, Filtering {
+    }
+    interface FindOptions extends CommandOptions, Projection, Filtering {
+    }
+    interface FindOneOptions extends CommandOptions, Projection, Filtering {
+        sort?: string[];
+        offset?: number;
+    }
+    interface FindManyOptions extends FindOneOptions {
+        limit?: number;
+        distinct?: boolean;
+        maxEagerFetch?: number;
+        maxSubQueries?: number;
+        onTransformRow?: TransformRowFunction;
+    }
+    interface UpdateOptions extends CommandOptions, Projection, Filtering {
+    }
+    interface UpdateManyOptions extends CommandOptions, Filtering {
+    }
+    /**
+     * @deprecated
+     */
+    type FindAllOptions = FindManyOptions;
+    /**
+     * @deprecated
+     */
+    type DestroyOptions = DeleteOptions;
+    /**
+     * @deprecated
+     */
+    type UpdateAllOptions = UpdateManyOptions;
+}
+interface RepositoryEvents {
+    execute: (request: QueryRequest) => void;
+    error: (error: Error) => void;
+    acquire: (connection: SqbConnection) => Promise<void>;
+}
+declare const Repository_base: Type<import("strict-typed-events").TypedEventEmitter<any, RepositoryEvents, RepositoryEvents>>;
+export declare class Repository<T> extends Repository_base {
+    private readonly _executor;
+    private readonly _entity;
+    private readonly _schema?;
+    constructor(entityDef: EntityMetadata, executor: SqbClient | SqbConnection, schema?: string);
+    get entity(): EntityMetadata;
+    get type(): Type<T>;
+    create(values: EntityInput<T>, options?: Repository.CreateOptions): Promise<EntityOutput<T>>;
+    createOnly(values: EntityInput<T>, options?: StrictOmit<Repository.CreateOptions, keyof Projection>): Promise<void>;
+    exists(keyValue: any | Record<string, any>, options?: Repository.ExistsOptions): Promise<boolean>;
+    count(options?: Repository.CountOptions): Promise<number>;
+    find(keyValue: any | Record<string, any>, options?: Repository.FindOptions): Promise<EntityOutput<T> | undefined>;
+    findOne(options?: Repository.FindOneOptions): Promise<EntityOutput<T> | undefined>;
+    findMany(options?: Repository.FindManyOptions): Promise<EntityOutput<T>[]>;
+    delete(keyValue: any | Record<string, any>, options?: Repository.DeleteOptions): Promise<boolean>;
+    deleteMany(options?: Repository.DeleteManyOptions): Promise<number>;
+    update(keyValue: any | Record<string, any>, values: EntityInput<T>, options?: Repository.UpdateOptions): Promise<EntityOutput<T> | undefined>;
+    updateOnly(keyValue: any | Record<string, any>, values: EntityInput<T>, options?: StrictOmit<Repository.UpdateOptions, keyof Projection>): Promise<boolean>;
+    updateMany(values: EntityInput<T>, options?: Repository.UpdateManyOptions): Promise<number>;
+    /**
+     *
+     * @deprecated
+     */
+    destroy(keyValue: any | Record<string, any>, options?: Repository.DeleteOptions): Promise<boolean>;
+    /**
+     *
+     * @deprecated
+     */
+    destroyAll(options?: Repository.DeleteManyOptions): Promise<number>;
+    /**
+     *
+     * @deprecated
+     */
+    findAll(options?: Repository.FindManyOptions): Promise<EntityOutput<T>[]>;
+    /**
+     *
+     * @deprecated
+     */
+    updateAll(values: EntityInput<T>, options?: Repository.UpdateManyOptions): Promise<number>;
+    protected _execute(fn: TransactionFunction, opts?: Repository.CommandOptions): Promise<any>;
+    protected _create(values: EntityInput<T>, options: Repository.CreateOptions & {
+        connection: SqbConnection;
+        returning?: boolean;
+    }): Promise<any>;
+    protected _exists(keyValue: any | Record<string, any>, options: Repository.ExistsOptions & {
+        connection: SqbConnection;
+    }): Promise<boolean>;
+    protected _count(options: Repository.CountOptions & {
+        connection: SqbConnection;
+    }): Promise<number>;
+    protected _findMany(options: Repository.FindManyOptions & {
+        connection: SqbConnection;
+    }): Promise<EntityOutput<T>[]>;
+    protected _findOne(options: Repository.FindOneOptions & {
+        connection: SqbConnection;
+    }): Promise<EntityOutput<T> | undefined>;
+    protected _find(keyValue: any | Record<string, any>, options: Repository.FindOptions & {
+        connection: SqbConnection;
+    }): Promise<EntityOutput<T> | undefined>;
+    protected _delete(keyValue: any | Record<string, any>, options: Repository.DeleteOptions & {
+        connection: SqbConnection;
+    }): Promise<boolean>;
+    protected _deleteMany(options: Repository.DeleteManyOptions & {
+        connection: SqbConnection;
+    }): Promise<number>;
+    protected _update(keyValue: any | Record<string, any>, values: EntityInput<T>, options: Repository.UpdateOptions & {
+        connection: SqbConnection;
+    }): Promise<Record<string, any> | undefined>;
+    protected _updateMany(values: EntityInput<T>, options: Repository.UpdateManyOptions & {
+        connection: SqbConnection;
+    }): Promise<number>;
+}
+export {};

package/types/orm/util/apply-mixins.d.ts

@@ -0,0 +1 @@
+export declare function applyMixins(derivedCtor: any, baseCtor: any, filter?: (k: string) => boolean): void;

package/types/orm/util/extract-keyvalues.d.ts

@@ -0,0 +1,2 @@
+import { EntityMetadata } from '../model/entity-metadata.js';
+export declare function extractKeyValues<T>(entityDef: EntityMetadata, valueOrInstance: any | Record<string, any> | T, keepOther?: boolean): Record<string, any>;

package/types/orm/util/orm.helper.d.ts

@@ -0,0 +1,13 @@
+import { Type } from 'ts-gems';
+import { AssociationFieldMetadata } from '../model/association-field-metadata.js';
+import type { ColumnFieldMetadata } from '../model/column-field-metadata.js';
+import { EmbeddedFieldMetadata } from '../model/embedded-field-metadata.js';
+import type { EntityMetadata } from '../model/entity-metadata.js';
+import type { TypeThunk } from '../orm.type.js';
+export declare function isClass(fn: any): fn is Type;
+export declare function isEntityClass(fn: any): fn is Type;
+export declare function isColumnField(f: any): f is ColumnFieldMetadata;
+export declare const isEmbeddedField: (f: any) => f is EmbeddedFieldMetadata;
+export declare const isAssociationField: (f: any) => f is AssociationFieldMetadata;
+export declare function resolveEntity(ctorThunk: TypeThunk): Promise<Type | undefined>;
+export declare function resolveEntityMeta(ctorThunk: TypeThunk): Promise<EntityMetadata | undefined>;

package/types/orm/util/serialize-field.d.ts

@@ -0,0 +1,2 @@
+import { FieldMetadata } from '../model/field-metadata.js';
+export declare function serializeColumn(col: FieldMetadata, v: any): any;

package/types/types.d.ts

@@ -0,0 +1,12 @@
+import { Builtin, DeepPickWritable } from 'ts-gems';
+export type EntityInput<T> = DeepNullablePartial<DeepPickWritable<T>>;
+export type EntityOutput<T> = DeepPartial<T>;
+export type DeepNullablePartial<T> = _DeepNullablePartial<T>;
+type _DeepNullablePartial<T> = T extends Builtin ? T : T extends Promise<infer U> ? Promise<DeepNullablePartial<U>> : T extends (infer U)[] ? DeepNullablePartial<U>[] : {
+    [P in keyof T]?: DeepNullablePartial<Exclude<T[P], undefined>> | null;
+};
+export type DeepPartial<T> = _DeepPartial<T>;
+type _DeepPartial<T> = T extends Builtin ? T : T extends Promise<infer U> ? Promise<DeepPartial<U>> : T extends (infer U)[] ? DeepPartial<U>[] : {
+    [P in keyof T]?: DeepPartial<Exclude<T[P], undefined>>;
+};
+export {};