@tstdl/base 0.91.28 → 0.91.30

package/.eslintrc.json

@@ -149,7 +149,11 @@
     "@stylistic/quotes": ["warn", "single"],
     "@stylistic/semi": ["warn", "always"],
     "@stylistic/multiline-ternary":  ["warn", "always-multiline"],
-    "@stylistic/generator-star-spacing": ["warn", { "before": false, "after": true }],
+    "@stylistic/generator-star-spacing":  ["error", {
+      "named": "before",
+      "anonymous": "neither",
+      "method": "before"
+    }],
     "@stylistic/indent": ["off"],
     "@stylistic/max-len": ["off"],
     "@stylistic/object-curly-spacing": ["warn", "always"],

package/{reflection/reflection-data-map.d.ts → data-structures/context-data-map.d.ts}

@@ -1,10 +1,11 @@
 import type { Record } from '../types.js';
-export declare class ReflectionDataMap {
+export declare class ContextDataMap {
     private readonly data;
     constructor();
     has(key: PropertyKey): boolean;
     tryGet<T>(key: PropertyKey): T | undefined;
+    tryGet<T, D>(key: PropertyKey, defaultValue: D): T | D;
     get<T>(key: PropertyKey): T;
     set(key: PropertyKey, value: any, mergeValue?: boolean): void;
-    setMany(data: Record, mergeValues?: boolean): void;
+    setMany(data: Record | readonly [PropertyKey, any][], mergeValues?: boolean): void;
 }

package/{reflection/reflection-data-map.js → data-structures/context-data-map.js}

@@ -1,7 +1,7 @@
 import { merge } from '../utils/merge.js';
 import { objectEntries } from '../utils/object/object.js';
-import { isUndefined } from '../utils/type-guards.js';
-export class ReflectionDataMap {
+import { isArray, isUndefined } from '../utils/type-guards.js';
+export class ContextDataMap {
     data;
     constructor() {
         this.data = new Map();
@@ -9,13 +9,17 @@ export class ReflectionDataMap {
     has(key) {
         return this.data.has(key);
     }
-    tryGet(key) {
-        return this.data.get(key);
+    tryGet(key, defaultValue) {
+        const value = this.data.get(key);
+        if (isUndefined(value)) {
+            return defaultValue;
+        }
+        return value;
     }
     get(key) {
         const data = this.tryGet(key);
         if (isUndefined(data)) {
-            throw new Error(`No data for ${String(key)} available.`);
+            throw new Error(`No data for key "${String(key)}" available.`);
         }
         return data;
     }
@@ -29,7 +33,10 @@ export class ReflectionDataMap {
         this.data.set(key, newData);
     }
     setMany(data, mergeValues = false) {
-        for (const [key, value] of objectEntries(data)) {
+        const entries = isArray(data)
+            ? data
+            : objectEntries(data);
+        for (const [key, value] of entries) {
             this.set(key, value, mergeValues);
         }
     }

package/data-structures/index.d.ts

@@ -8,6 +8,7 @@ export * from './array-list.js';
 export * from './cache.js';
 export * from './circular-buffer.js';
 export * from './collection.js';
+export * from './context-data-map.js';
 export * from './dictionary.js';
 export * from './distinct-collection.js';
 export * from './index-out-of-bounds.error.js';

package/data-structures/index.js

@@ -8,6 +8,7 @@ export * from './array-list.js';
 export * from './cache.js';
 export * from './circular-buffer.js';
 export * from './collection.js';
+export * from './context-data-map.js';
 export * from './dictionary.js';
 export * from './distinct-collection.js';
 export * from './index-out-of-bounds.error.js';

package/examples/orm/drizzle.config.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("drizzle-kit").Config;
+export default _default;

package/examples/orm/drizzle.config.js

@@ -0,0 +1,5 @@
+import { defineConfig } from 'drizzle-kit';
+export default defineConfig({
+    dialect: 'postgresql',
+    schema: './schemas.js'
+});

package/examples/orm/schemas.d.ts

@@ -0,0 +1,3 @@
+import { User } from './user.model.js';
+export declare const mySchema: import("../../orm/database-schema.js").DatabaseSchema<"my_application">;
+export declare const user: import("../../orm/index.js").PgTableFromType<"my_application", typeof User>;

package/examples/orm/schemas.js

@@ -0,0 +1,4 @@
+import { databaseSchema } from '../../orm/database-schema.js';
+import { User } from './user.model.js';
+export const mySchema = databaseSchema('my_application');
+export const user = mySchema.getTable(User);

package/examples/orm/test.js

@@ -0,0 +1,10 @@
+import { eq } from 'drizzle-orm';
+import { drizzle } from 'drizzle-orm/node-postgres';
+import { pgSchema, uuid } from 'drizzle-orm/pg-core';
+import * as schema from './schemas.js';
+const db = drizzle('', { schema });
+const query = eq(schema.user, 1);
+const x = pgSchema('').table('test', {
+    id: uuid().defaultRandom().primaryKey()
+});
+await db.insert(x).values({});

package/examples/orm/user.model.d.ts

@@ -0,0 +1,9 @@
+import { Entity, Integer } from '../../orm/index.js';
+export declare class User extends Entity {
+    static entityName: string;
+    name: string;
+    nickNames: string[];
+    age: Integer | null;
+    hasAge: boolean;
+    mail: string;
+}

package/examples/orm/user.model.js

@@ -0,0 +1,39 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { Entity, Integer, Unique } from '../../orm/index.js';
+import { Array, Property } from '../../schema/index.js';
+export class User extends Entity {
+    static entityName = 'User';
+    name;
+    nickNames;
+    age;
+    hasAge;
+    mail;
+}
+__decorate([
+    Property(),
+    __metadata("design:type", String)
+], User.prototype, "name", void 0);
+__decorate([
+    Array(String),
+    __metadata("design:type", Array)
+], User.prototype, "nickNames", void 0);
+__decorate([
+    Integer({ nullable: true }),
+    __metadata("design:type", Object)
+], User.prototype, "age", void 0);
+__decorate([
+    Property(),
+    __metadata("design:type", Boolean)
+], User.prototype, "hasAge", void 0);
+__decorate([
+    Unique(),
+    __metadata("design:type", String)
+], User.prototype, "mail", void 0);

package/key-value-store/index.d.ts

@@ -5,4 +5,3 @@
  */
 export * from './key-value-store.provider.js';
 export * from './key-value.store.js';
-export * from './mongo/index.js';

package/key-value-store/index.js

@@ -5,4 +5,3 @@
  */
 export * from './key-value-store.provider.js';
 export * from './key-value.store.js';
-export * from './mongo/index.js';

package/key-value-store/key-value.store.d.ts

@@ -1,24 +1,23 @@
-import type { Resolvable } from '../injector/interfaces.js';
-import { resolveArgumentType } from '../injector/interfaces.js';
+import { type Resolvable, resolveArgumentType } from '../injector/interfaces.js';
 import type { StringMap } from '../types.js';
-/** key value store module */
+/** Key value store module */
 export type KeyValueStoreArgument = string;
 export declare abstract class KeyValueStore<KV extends StringMap> implements Resolvable<KeyValueStoreArgument> {
     readonly module: string;
     readonly [resolveArgumentType]: KeyValueStoreArgument;
     constructor(module: string);
-    /** get value of key */
+    /** Get value of key */
     abstract get<K extends keyof KV>(key: K): Promise<KV[K] | undefined>;
-    /** get value of key */
+    /** Get value of key */
     abstract get<K extends keyof KV, D>(key: K, defaultValue: D): Promise<KV[K] | D>;
-    /** set key */
+    /** Set key */
     abstract set<K extends keyof KV>(key: K, value: KV[K]): Promise<void>;
-    /** set multiple keys */
+    /** Set multiple keys */
     abstract setMany(keyValues: Partial<KV>): Promise<void>;
-    /** delete key */
+    /** Delete key */
     abstract delete(key: keyof KV): Promise<boolean>;
-    /** delete multiple keys */
+    /** Delete multiple keys */
     abstract deleteMany(keys: (keyof KV)[]): Promise<void>;
-    /** delete all keys */
+    /** Delete all keys */
     abstract clear(): Promise<void>;
 }

package/key-value-store/mongo/mongo-key-value.store.js

@@ -9,10 +9,11 @@ var __metadata = (this && this.__metadata) || function (k, v) {
 };
 import { getNewId } from '../../database/index.js';
 import { Singleton } from '../../injector/index.js';
-import { KeyValueStore, MongoKeyValueStoreProvider } from '../../key-value-store/index.js';
+import { KeyValueStore } from '../../key-value-store/index.js';
 import { currentTimestamp } from '../../utils/date-time.js';
 import { objectEntries } from '../../utils/object/object.js';
 import { assertString, isUndefined } from '../../utils/type-guards.js';
+import { MongoKeyValueStoreProvider } from './mongo-key-value-store.provider.js';
 import { MongoKeyValueRepository } from './mongo-key-value.repository.js';
 let MongoKeyValueStore = class MongoKeyValueStore extends KeyValueStore {
     keyValueRepository;

package/orm/database-schema.d.ts

@@ -0,0 +1,8 @@
+import { type PgTableFromType } from './drizzle/schema-converter.js';
+import type { EntityType } from './entity.js';
+export declare class DatabaseSchema<Name extends string> {
+    readonly name: Name;
+    constructor(name: Name);
+    getTable<T extends EntityType>(type: T): PgTableFromType<Name, T>;
+}
+export declare function databaseSchema<Name extends string>(name: Name): DatabaseSchema<Name>;

package/orm/database-schema.js

@@ -0,0 +1,13 @@
+import { getDrizzleTableFromType } from './drizzle/schema-converter.js';
+export class DatabaseSchema {
+    name;
+    constructor(name) {
+        this.name = name;
+    }
+    getTable(type) {
+        return getDrizzleTableFromType(this.name, type);
+    }
+}
+export function databaseSchema(name) {
+    return new DatabaseSchema(name);
+}

package/orm/decorators.d.ts

@@ -1 +1,27 @@
+export type OrmTableReflectionData = {
+    name?: string;
+    unique?: UniqueReflectionData[];
+};
+export type OrmColumnReflectionData = {
+    name?: string;
+    primaryKey?: boolean;
+    unique?: UniqueReflectionData;
+    uuid?: {
+        defaultRandom?: boolean;
+    };
+};
+type UniqueReflectionData = {
+    name?: string;
+    columns?: string[];
+    options?: {
+        nulls?: 'distinct' | 'not distinct';
+    };
+};
+export declare function createTableDecorator(data?: OrmTableReflectionData): ClassDecorator;
+export declare function createColumnDecorator(data?: OrmColumnReflectionData): PropertyDecorator;
+export declare function createTableAndColumnDecorator(data?: OrmColumnReflectionData): ClassDecorator & PropertyDecorator;
+export declare function Column(options: OrmColumnReflectionData): PropertyDecorator;
 export declare function PrimaryKey(): PropertyDecorator;
+export declare function Unique(name?: string, options?: UniqueReflectionData['options']): PropertyDecorator;
+export declare function Unique(name: string | undefined, columns: [string, ...string[]], options?: UniqueReflectionData['options']): ClassDecorator;
+export {};

package/orm/decorators.js

@@ -1,4 +1,23 @@
-import { createPropertyDecorator } from '../reflection/utils.js';
+import { createClassDecorator, createDecorator, createPropertyDecorator } from '../reflection/utils.js';
+import { isArray } from '../utils/type-guards.js';
+export function createTableDecorator(data) {
+    return createClassDecorator({ data: { orm: data }, mergeData: true });
+}
+export function createColumnDecorator(data) {
+    return createPropertyDecorator({ data: { orm: data }, mergeData: true });
+}
+export function createTableAndColumnDecorator(data) {
+    return createDecorator({ class: true, property: true, data: { orm: data }, mergeData: true });
+}
+export function Column(options) {
+    return createColumnDecorator({ ...options });
+}
 export function PrimaryKey() {
-    return createPropertyDecorator({ data: { orm: { primaryKey: true } }, mergeData: true });
+    return createColumnDecorator({ primaryKey: true });
+}
+export function Unique(name, columnsOrOptions, options) {
+    if (isArray(columnsOrOptions)) {
+        return createTableDecorator({ unique: [{ name, columns: columnsOrOptions, options }] });
+    }
+    return createColumnDecorator({ unique: { name, options: columnsOrOptions ?? options } });
 }

package/orm/drizzle/schema-converter.d.ts

@@ -0,0 +1,19 @@
+import type { BuildColumns, NotNull } from 'drizzle-orm';
+import { type PgTableWithColumns } from 'drizzle-orm/pg-core';
+import type { SnakeCase } from 'type-fest';
+import type { Enumeration, Type } from '../../types.js';
+import type { EntityType } from '../entity.js';
+import type { ColumnBuilder } from '../types.js';
+type Column<Name extends string, T> = null extends T ? ColumnBuilder<T, Name> : NotNull<ColumnBuilder<T, Name>>;
+export declare const getDrizzleTableFromType: typeof _getDrizzleTableFromType;
+export type PgTableFromType<S extends string, T extends Type, TableName extends string = T extends EntityType ? SnakeCase<T['entityName']> : string> = PgTableWithColumns<{
+    name: TableName;
+    schema: S;
+    columns: BuildColumns<TableName, {
+        [P in keyof InstanceType<T>]: Column<Extract<P, string>, InstanceType<T>[P]>;
+    }, 'pg'>;
+    dialect: 'pg';
+}>;
+export declare function _getDrizzleTableFromType<S extends string, T extends Type>(schemaName: S, type: T, tableName?: string): PgTableFromType<S, T>;
+export declare function registerEnum(enumeration: Enumeration, name: string): void;
+export {};

package/orm/drizzle/schema-converter.js

@@ -0,0 +1,116 @@
+import { toSnakeCase } from 'drizzle-orm/casing';
+import { boolean, doublePrecision, integer, pgSchema, text, unique, uuid } from 'drizzle-orm/pg-core';
+import { NotSupportedError } from '../../errors/not-supported.error.js';
+import { reflectionRegistry } from '../../reflection/registry.js';
+import { ArraySchema, BooleanSchema, EnumerationSchema, getObjectSchema, NullableSchema, NumberSchema, OptionalSchema, StringSchema } from '../../schema/index.js';
+import { enumValues } from '../../utils/enum.js';
+import { memoize, memoizeSingle } from '../../utils/function/memoize.js';
+import { fromEntries, objectEntries } from '../../utils/object/object.js';
+import { assertDefinedPass, assertStringPass, isArray, isDefined, isString, isUndefined } from '../../utils/type-guards.js';
+import { UuidSchema } from '../schemas/uuid.js';
+const getDbSchema = memoizeSingle(pgSchema);
+export const getDrizzleTableFromType = memoize(_getDrizzleTableFromType);
+export function _getDrizzleTableFromType(schemaName, type, tableName = getDefaultTableName(type)) {
+    const metadata = reflectionRegistry.getMetadata(type);
+    if (isUndefined(metadata)) {
+        throw new Error('Type does not have reflection metadata.');
+    }
+    const dbSchema = getDbSchema(schemaName);
+    const tableReflectionData = metadata.data.tryGet('orm');
+    const objectSchema = getObjectSchema(type);
+    const entries = objectEntries(objectSchema.properties).map(([property, schema]) => {
+        const columnReflectionData = metadata.properties.get(property)?.data.tryGet('orm');
+        const propertyName = columnReflectionData?.name ?? assertStringPass(toSnakeCase(property));
+        return [
+            property,
+            getPostgresColumn(tableName, propertyName, dbSchema, schema, columnReflectionData ?? {})
+        ];
+    });
+    function getColumn(table, propertyName) {
+        return assertDefinedPass(table[propertyName], `Property "${propertyName}" does not exist on ${type.name}`);
+    }
+    const drizzleSchema = dbSchema.table(tableName, fromEntries(entries), (table) => {
+        const uniqueEntries = tableReflectionData?.unique?.map((data, index) => {
+            const columns = data.columns?.map((column) => getColumn(table, column));
+            let constraint = unique(isDefined(data.name) ? toSnakeCase(data.name) : undefined).on(...columns);
+            if (data.options?.nulls == 'not distinct') {
+                constraint = constraint.nullsNotDistinct();
+            }
+            return [`unique_${index}`, constraint];
+        });
+        return {
+            ...isDefined(uniqueEntries) ? fromEntries(uniqueEntries) : undefined
+        };
+    });
+    return drizzleSchema; // eslint-disable-line @typescript-eslint/no-unsafe-return
+}
+function getPostgresColumn(tableName, columnName, dbSchema, propertySchema, reflectionData) {
+    let nullable = false;
+    let array = false;
+    let baseSchema = propertySchema;
+    while (true) {
+        if ((baseSchema instanceof NullableSchema) || (baseSchema instanceof OptionalSchema)) {
+            nullable = true;
+            baseSchema = baseSchema.schema;
+        }
+        else if (baseSchema instanceof ArraySchema) {
+            array = true;
+            baseSchema = baseSchema.itemSchema;
+        }
+        else {
+            break;
+        }
+    }
+    let column = getPostgresBaseColumn(tableName, columnName, dbSchema, baseSchema);
+    if (array) {
+        column = column.array();
+    }
+    if (!nullable) {
+        column = column.notNull();
+    }
+    if (isDefined(reflectionData.unique)) {
+        column = column.unique(reflectionData.unique.name, isString(reflectionData.unique.options?.nulls) ? { nulls: reflectionData.unique.options.nulls } : undefined);
+    }
+    if (reflectionData.primaryKey == true) {
+        column = column.primaryKey();
+    }
+    return column;
+}
+function getPostgresBaseColumn(tableName, columnName, dbSchema, schema) {
+    if (schema instanceof NumberSchema) {
+        return schema.integer
+            ? integer(columnName)
+            : doublePrecision(columnName);
+    }
+    if (schema instanceof UuidSchema) {
+        let column = uuid(columnName);
+        if (schema.defaultRandom) {
+            column = column.defaultRandom();
+        }
+        return column;
+    }
+    if (schema instanceof StringSchema) {
+        return text(columnName);
+    }
+    if (schema instanceof BooleanSchema) {
+        return boolean(columnName);
+    }
+    if (schema instanceof EnumerationSchema) {
+        const pgEnum = getPgEnum(tableName, columnName, dbSchema, schema.enumeration);
+        return pgEnum(columnName);
+    }
+    throw new NotSupportedError(`Schema ${schema.constructor.name} not supported`);
+}
+const enums = new Map();
+export function registerEnum(enumeration, name) {
+    enums.set(enumeration, name);
+}
+function getPgEnum(tableName, columnName, dbSchema, enumeration) {
+    const values = (isArray(enumeration) ? enumeration : enumValues(enumeration))
+        .map((value) => value.toString());
+    const enumName = enums.get(enumeration) ?? `${tableName}_${columnName}_enum`;
+    return dbSchema.enum(enumName, values);
+}
+function getDefaultTableName(type) {
+    return toSnakeCase(isString(type.entityName) ? type.entityName : type.name);
+}

package/orm/entity.d.ts

@@ -1,4 +1,8 @@
-import type { Record, TypedOmit } from '../types.js';
+import type { Record, Type, TypedOmit } from '../types.js';
+import { type HasDefault, type IsPrimaryKey, Uuid } from './types.js';
+export interface EntityType<T extends Entity = Entity> extends Type<T> {
+    readonly entityName: string;
+}
 export declare abstract class EntityMetadata {
     revision: number;
     revisionTimestamp: number;
@@ -7,7 +11,7 @@ export declare abstract class EntityMetadata {
     attributes: Record;
 }
 export declare abstract class Entity {
-    id: string;
+    id: IsPrimaryKey<HasDefault<Uuid>>;
     metadata: EntityMetadata;
 }
 export type NewEntity<T extends Entity> = TypedOmit<T, 'id' | 'metadata'> & {

package/orm/entity.js

@@ -8,6 +8,8 @@ var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
 import { NumberProperty, Property, any, record } from '../schema/index.js';
+import { PrimaryKey } from './decorators.js';
+import { Uuid } from './types.js';
 export class EntityMetadata {
     revision;
     revisionTimestamp;
@@ -37,13 +39,11 @@ __decorate([
 ], EntityMetadata.prototype, "attributes", void 0);
 export class Entity {
     id;
+    // @Property(EntityMetadata)
     metadata;
 }
 __decorate([
-    Property(),
-    __metadata("design:type", String)
+    PrimaryKey(),
+    Uuid({ defaultRandom: true }),
+    __metadata("design:type", Object)
 ], Entity.prototype, "id", void 0);
-__decorate([
-    Property(EntityMetadata),
-    __metadata("design:type", EntityMetadata)
-], Entity.prototype, "metadata", void 0);

package/orm/index.d.ts

@@ -1,7 +1,6 @@
 export * from './decorators.js';
+export * from './drizzle/schema-converter.js';
 export * from './entity.js';
 export * from './query.js';
 export * from './repository.js';
-export * from './schema-converter.js';
-export * from './schema.js';
 export * from './types.js';

package/orm/index.js

@@ -1,7 +1,6 @@
 export * from './decorators.js';
+export * from './drizzle/schema-converter.js';
 export * from './entity.js';
 export * from './query.js';
 export * from './repository.js';
-export * from './schema-converter.js';
-export * from './schema.js';
 export * from './types.js';

package/orm/repository.d.ts

@@ -1,5 +1,6 @@
-import type { Paths, Type, TypedOmit } from '../types.js';
-import type { Entity, EntityMetadata, NewEntity } from './entity.js';
+import type { Paths, TypedOmit } from '../types.js';
+import { SQL } from 'drizzle-orm';
+import type { Entity, EntityMetadata, EntityType, NewEntity } from './entity.js';
 import type { Query } from './query.js';
 export declare const repositoryType: unique symbol;
 export type OrderOptions<T extends Entity> = {
@@ -17,34 +18,36 @@ export type EntityMetadataUpdate = {
     metadata?: Partial<EntityMetadata>;
 };
 export type EntityUpdate<T extends Entity> = Partial<TypedOmit<T, 'metadata'>> & EntityMetadataUpdate;
+export declare const entityType: import("../injector/token.js").InjectionToken<EntityType<any>, never>;
 export declare abstract class EntityRepository<T extends Entity = Entity> {
-    readonly type: Type<T>;
+    readonly type: EntityType<T>;
+    readonly schema: import("./drizzle/schema-converter.js").PgTableFromType<"", EntityType<Entity>, string>;
     readonly database: import("drizzle-orm/node-postgres").NodePgDatabase<Record<string, never>> & {
-        $client: null;
+        $client: import("drizzle-orm/node-postgres").NodePgClient;
     };
-    load(_id: string): Promise<T>;
-    abstract tryLoad(id: string): Promise<T | undefined>;
-    abstract loadByFilter(query: Query<T>, options?: LoadOptions<T>): Promise<T>;
-    abstract tryLoadByFilter(query: Query<T>, options?: LoadOptions<T>): Promise<T | undefined>;
-    abstract loadMany(ids: string[], options?: LoadManyOptions<T>): Promise<T[]>;
-    abstract loadManyCursor(ids: string[], options?: LoadManyOptions<T>): AsyncIterableIterator<T>;
-    abstract loadManyByFilter(query: Query<T>, options?: LoadManyOptions<T>): Promise<T[]>;
-    abstract loadManyByFilterCursor(query: Query<T>, options?: LoadManyOptions<T>): AsyncIterableIterator<T>;
-    abstract loadAll(options?: LoadManyOptions<T>): Promise<T[]>;
-    abstract loadAllCursor(options?: LoadManyOptions<T>): AsyncIterableIterator<T>;
-    abstract count(): Promise<number>;
-    abstract countByFilter(query: Query<T>): Promise<number>;
-    abstract has(id: string): Promise<boolean>;
-    abstract hasByFilter(query: Query<T>): Promise<boolean>;
-    abstract hasAll(ids: string[]): Promise<boolean>;
-    abstract insert(entity: NewEntity<T>): Promise<T>;
+    load(id: string): Promise<T>;
+    tryLoad(id: string): Promise<T | undefined>;
+    loadByQuery(query: Query<T> | SQL | undefined, options?: LoadOptions<T>): Promise<T>;
+    tryLoadByQuery(query: Query<T> | SQL | undefined, options?: LoadOptions<T>): Promise<T | undefined>;
+    loadMany(ids: string[], options?: LoadManyOptions<T>): Promise<T[]>;
+    loadManyCursor(ids: string[], options?: LoadManyOptions<T>): AsyncIterableIterator<T>;
+    loadManyByQuery(query: Query<T> | SQL | undefined, options?: LoadManyOptions<T>): Promise<T[]>;
+    loadManyByQueryCursor(query: Query<T> | SQL | undefined, options?: LoadManyOptions<T>): AsyncIterableIterator<T>;
+    loadAll(options?: LoadManyOptions<T>): Promise<T[]>;
+    loadAllCursor(options?: LoadManyOptions<T>): AsyncIterableIterator<T>;
+    count(): Promise<number>;
+    countByQuery(query: Query<T> | SQL): Promise<number>;
+    has(id: string): Promise<boolean>;
+    hasByQuery(query: Query<T> | SQL): Promise<boolean>;
+    hasAll(ids: string[]): Promise<boolean>;
+    insert(_entity: NewEntity<T>): Promise<T>;
     abstract insertMany(entities: NewEntity<T>[]): Promise<T[]>;
     abstract update(id: string, update: EntityUpdate<T>): Promise<void>;
-    abstract updateByFilter(query: Query<T>, update: EntityUpdate<T>): Promise<void>;
+    abstract updateByQuery(query: Query<T>, update: EntityUpdate<T>): Promise<void>;
     abstract updateMany(ids: string[], update: EntityUpdate<T>): Promise<void>;
-    abstract updateManyByFilter(filter: Query<T>, update: EntityUpdate<T>): Promise<void>;
+    abstract updateManyByQuery(filter: Query<T>, update: EntityUpdate<T>): Promise<void>;
     abstract delete(id: string): Promise<boolean>;
     abstract deleteMany(ids: string[]): Promise<number>;
-    abstract deleteByFilter(query: Query<T>): Promise<boolean>;
-    abstract deleteManyByFilter(query: Query<T>): Promise<number>;
+    abstract deleteByQuery(query: Query<T>): Promise<boolean>;
+    abstract deleteManyByQuery(query: Query<T>): Promise<number>;
 }