@tstdl/base 0.92.85 → 0.92.87

package/document-management/server/services/index.d.ts

@@ -1 +1,2 @@
+export * from './document-management-ancillary.service.js';
 export * from './document-management.service.js';

package/document-management/server/services/index.js

@@ -1 +1,2 @@
+export * from './document-management-ancillary.service.js';
 export * from './document-management.service.js';

package/eslint.config.js

@@ -42,6 +42,7 @@ export default [
       '@typescript-eslint/no-floating-promises': 'error',
       '@typescript-eslint/no-import-type-side-effects': 'error',
       '@typescript-eslint/no-inferrable-types': ['warn', { ignoreParameters: true, ignoreProperties: true }],
+      '@typescript-eslint/no-misused-spread': 'off',
       '@typescript-eslint/no-non-null-assertion': 'off',
       '@typescript-eslint/no-unnecessary-condition': ['warn', { allowConstantLoopConditions: 'only-allowed-literals', checkTypePredicates: true }],
       '@typescript-eslint/no-unsafe-assignment': 'off',

package/examples/document-management/main.d.ts

@@ -1 +1,6 @@
 import '../../polyfills.js';
+import type { DocumentCollection } from '../../document-management/index.js';
+import { DocumentManagementAncillaryService } from '../../document-management/server/index.js';
+export declare class TestDocumentManagementAncillaryService extends DocumentManagementAncillaryService {
+    resolveNames(collections: DocumentCollection[]): Promise<string[]>;
+}

package/examples/document-management/main.js

@@ -1,19 +1,37 @@
+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;
+};
 import '../../polyfills.js';
 import { Application } from '../../application/application.js';
+import { DocumentManagementAncillaryService } from '../../document-management/server/index.js';
 import { configureDocumentManagement, migrateDocumentManagementSchema } from '../../document-management/server/module.js';
 import { DocumentManagementService } from '../../document-management/server/services/document-management.service.js';
+import { Singleton } from '../../injector/index.js';
 import { injectAsync } from '../../injector/inject.js';
 import { configureS3ObjectStorage } from '../../object-storage/index.js';
+let TestDocumentManagementAncillaryService = class TestDocumentManagementAncillaryService extends DocumentManagementAncillaryService {
+    async resolveNames(collections) {
+        return collections.map((collection) => collection.metadata.attributes['name']);
+    }
+};
+TestDocumentManagementAncillaryService = __decorate([
+    Singleton()
+], TestDocumentManagementAncillaryService);
+export { TestDocumentManagementAncillaryService };
 async function bootstrap() {
     configureDocumentManagement({
+        ancillaryService: TestDocumentManagementAncillaryService,
+        fileObjectStorageModule: 'documents',
         database: {
             connection: {
                 database: 'xxx',
                 user: 'xxx',
                 password: 'xxx'
             }
-        },
-        fileObjectStorageModule: 'documents'
+        }
     });
     configureS3ObjectStorage({ endpoint: 'http://localhost:10000', accessKey: 'tstdl-dev', secretKey: 'tstdl-dev', bucketPerModule: true });
     await migrateDocumentManagementSchema();

package/examples/orm/schemas.d.ts

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

package/file/index.d.ts

@@ -1,2 +1,3 @@
 export * from './mime-type.js';
 export * from './mime-types.js';
+export * from './temporary-file.js';

package/file/index.js

@@ -1,2 +1,3 @@
 export * from './mime-type.js';
 export * from './mime-types.js';
+export * from './temporary-file.js';

package/file/temporary-file.d.ts

@@ -0,0 +1,17 @@
+export declare class TemporaryFile implements AsyncDisposable {
+    #private;
+    get path(): string;
+    static create(): TemporaryFile;
+    /**
+     * Use an existing file as a temporary file which gets deleted on disposal.
+     * @param path path to adopt
+     */
+    static adopt(path: string): TemporaryFile;
+    static from(content: string | Uint8Array | ReadableStream<Uint8Array>): Promise<TemporaryFile>;
+    read(): Promise<Uint8Array>;
+    readText(): Promise<string>;
+    readStream(): ReadableStream<Uint8Array>;
+    write(content: string | Uint8Array | ReadableStream<Uint8Array>): Promise<void>;
+    delete(): Promise<void>;
+    [Symbol.asyncDispose](): Promise<void>;
+}

package/file/temporary-file.js

@@ -0,0 +1,49 @@
+import { createReadStream } from 'node:fs';
+import { readFile, unlink, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { Readable } from 'node:stream';
+export class TemporaryFile {
+    #path = `${tmpdir()}/${crypto.randomUUID()}`;
+    get path() {
+        return this.#path;
+    }
+    static create() {
+        return new TemporaryFile();
+    }
+    /**
+     * Use an existing file as a temporary file which gets deleted on disposal.
+     * @param path path to adopt
+     */
+    static adopt(path) {
+        const file = new TemporaryFile();
+        file.#path = path;
+        return file;
+    }
+    static async from(content) {
+        const file = new TemporaryFile();
+        await file.write(content);
+        return file;
+    }
+    async read() {
+        return readFile(this.#path);
+    }
+    async readText() {
+        return readFile(this.#path, { encoding: 'utf8' });
+    }
+    readStream() {
+        const stream = createReadStream(this.#path);
+        return Readable.toWeb(stream);
+    }
+    async write(content) {
+        await writeFile(this.#path, content);
+    }
+    async delete() {
+        await unlink(this.#path);
+    }
+    async [Symbol.asyncDispose]() {
+        try {
+            await this.delete();
+        }
+        catch { }
+    }
+}

package/http/server/http-server-response.d.ts

@@ -32,5 +32,7 @@ export declare class HttpServerResponse {
     };
     constructor(response?: HttpServerResponseOptions);
     static fromObject(options?: HttpServerResponseOptions): HttpServerResponse;
+    static redirect(url: string, options?: HttpServerResponseOptions): HttpServerResponse;
     update(options: HttpServerResponseOptions): void;
 }
+export declare function redirect(url: string, options?: HttpServerResponseOptions): HttpServerResponse;

package/http/server/http-server-response.js

@@ -13,6 +13,16 @@ export class HttpServerResponse {
     static fromObject(options) {
         return new HttpServerResponse(options);
     }
+    static redirect(url, options) {
+        return new HttpServerResponse({
+            statusCode: 303,
+            ...options,
+            headers: {
+                Location: url,
+                ...options?.headers
+            }
+        });
+    }
     update(options) {
         this.statusCode = options.statusCode;
         this.statusMessage = options.statusMessage;
@@ -25,3 +35,6 @@ export class HttpServerResponse {
         }
     }
 }
+export function redirect(url, options) {
+    return HttpServerResponse.redirect(url, options);
+}

package/injector/index.d.ts

@@ -8,6 +8,7 @@ export * from './inject.js';
 export * from './injector.js';
 export * from './interfaces.js';
 export * from './provider.js';
+export * from './resolution.js';
 export * from './resolve-chain.js';
 export * from './resolve.error.js';
 export * from './symbols.js';

package/injector/index.js

@@ -8,6 +8,7 @@ export * from './inject.js';
 export * from './injector.js';
 export * from './interfaces.js';
 export * from './provider.js';
+export * from './resolution.js';
 export * from './resolve-chain.js';
 export * from './resolve.error.js';
 export * from './symbols.js';

package/injector/injector.js

@@ -12,6 +12,7 @@ import { assert, isArray, isBoolean, isDefined, isFunction, isNotNull, isNull, i
 import { setCurrentInjectionContext } from './inject.js';
 import { afterResolve } from './interfaces.js';
 import { isClassProvider, isFactoryProvider, isProviderWithInitializer, isTokenProvider, isValueProvider } from './provider.js';
+import { runInResolutionContext } from './resolution.js';
 import { ResolveChain } from './resolve-chain.js';
 import { ResolveError } from './resolve.error.js';
 import { injectMetadataSymbol, injectableMetadataSymbol } from './symbols.js';
@@ -264,7 +265,7 @@ export class Injector {
         }
         const injectionContext = injector.getInjectionContext(context, argument, chain);
         const previousInjectionContext = setCurrentInjectionContext(injectionContext);
-        const resolutionTag = Symbol(); // eslint-disable-line symbol-description
+        const resolutionTag = Symbol('ResolutionTag');
         try {
             const resolutionScoped = registration.options.lifecycle == 'resolution';
             const injectorScoped = registration.options.lifecycle == 'injector';
@@ -280,12 +281,16 @@ export class Injector {
             else if (singletonScoped && registration.resolutions.has(argumentIdentity)) {
                 return registration.resolutions.get(argumentIdentity);
             }
-            const value = injector._resolveProvider(resolutionTag, registration, resolveArgument, options, context, injectionContext, chain);
+            const resolutionContext = {
+                afterResolveRegistrations: []
+            };
+            const value = injector._resolveProvider(resolutionTag, registration, resolveArgument, options, context, resolutionContext, injectionContext, chain);
             const resolution = {
                 tag: resolutionTag,
                 registration,
                 value,
                 argument: injectionContext.argument,
+                afterResolveRegistrations: resolutionContext.afterResolveRegistrations,
                 afterResolveContext: injector.getAfterResolveContext(resolutionTag, context),
                 chain
             };
@@ -305,7 +310,7 @@ export class Injector {
             setCurrentInjectionContext(previousInjectionContext);
         }
     }
-    _resolveProvider(resolutionTag, registration, resolveArgument, options, context, injectionContext, chain) {
+    _resolveProvider(resolutionTag, registration, resolveArgument, options, context, resolutionContext, injectionContext, chain) {
         try {
             setResolving(registration.token, context, chain);
             const { provider } = registration;
@@ -319,7 +324,7 @@ export class Injector {
                 }
                 const parameters = (typeMetadata?.parameters ?? []).map((metadata) => this.resolveClassInjection(resolutionTag, context, provider.useClass, metadata, arg, chain));
                 try {
-                    result = { value: new provider.useClass(...parameters) };
+                    result = { value: runInResolutionContext(resolutionContext, () => Reflect.construct(provider.useClass, parameters)) };
                 }
                 catch (error) {
                     if (error instanceof ResolveError) {
@@ -344,7 +349,7 @@ export class Injector {
                 const arg = resolveArgument ?? provider.defaultArgument ?? provider.defaultArgumentProvider?.();
                 injectionContext.argument = arg;
                 try {
-                    result = { value: provider.useFactory(arg, this.getResolveContext(resolutionTag, context, chain)) };
+                    result = { value: runInResolutionContext(resolutionContext, () => provider.useFactory(arg, this.getResolveContext(resolutionTag, context, chain))) };
                 }
                 catch (error) {
                     throw new ResolveError('Error in provider factory.', chain, error);
@@ -484,7 +489,11 @@ function postProcess(context) {
     }
     derefForwardRefs(context);
     for (const resolution of context.resolutions) {
-        if (isFunction(resolution.value?.[afterResolve])) {
+        for (const afterResolveHandler of resolution.afterResolveRegistrations) {
+            const returnValue = afterResolveHandler(resolution.argument, resolution.afterResolveContext);
+            throwOnPromise(returnValue, 'registerAfterResolve()', resolution.chain);
+        }
+        if (!isTokenProvider(resolution.registration.provider) && isFunction(resolution.value?.[afterResolve])) {
             const returnValue = resolution.value[afterResolve](resolution.argument, resolution.afterResolveContext);
             throwOnPromise(returnValue, '[afterResolve]', resolution.chain);
         }
@@ -504,7 +513,10 @@ async function postProcessAsync(context) {
     }
     derefForwardRefs(context);
     for (const resolution of context.resolutions) {
-        if (isFunction(resolution.value?.[afterResolve])) {
+        for (const afterResolveHandler of resolution.afterResolveRegistrations) {
+            await afterResolveHandler(resolution.argument, resolution.afterResolveContext);
+        }
+        if (!isTokenProvider(resolution.registration.provider) && isFunction(resolution.value?.[afterResolve])) {
             await resolution.value[afterResolve](resolution.argument, resolution.afterResolveContext);
         }
         if (isProviderWithInitializer(resolution.registration.provider)) {

package/injector/interfaces.d.ts

@@ -13,5 +13,5 @@ export interface Resolvable<A = unknown, D extends Record = Record> extends Part
     readonly [resolveArgumentType]?: A;
 }
 export interface AfterResolve<A = unknown, D extends Record = Record> {
-    [afterResolve](argument: A, context: AfterResolveContext<D>): void | Promise<void>;
+    [afterResolve](argument: NoInfer<A>, context: AfterResolveContext<NoInfer<D>>): void | Promise<void>;
 }

package/injector/interfaces.js

@@ -1,2 +1,2 @@
 export const resolveArgumentType = Symbol('resolveArgumentType');
-export const afterResolve = Symbol('after resolve');
+export const afterResolve = Symbol('afterResolve');

package/injector/resolution.d.ts

@@ -0,0 +1,15 @@
+import type { Record } from '../types.js';
+import type { Resolvable } from './interfaces.js';
+import type { AfterResolveContext } from './types.js';
+export type AfterResolveHandler<A, D extends Record> = (argument: A, context: AfterResolveContext<D>) => void | Promise<void>;
+export type ResolutionContext<A> = {
+    afterResolveRegistrations: AfterResolveHandler<A, any>[];
+};
+declare const assertInResolutionContext: (debugFnOrMessage: import("../types.js").Function | string) => void, getCurrentResolutionContext: {
+    (required: true, debugFn: import("../types.js").Function): ResolutionContext<any>;
+    (required?: false, debugFn?: import("../types.js").Function): ResolutionContext<any> | null;
+    (required: boolean, debugFn: import("../types.js").Function): ResolutionContext<any> | null;
+}, runInResolutionContext: <ReturnT>(context: ResolutionContext<any>, fn: () => ReturnT) => ReturnT;
+export declare function registerAfterResolve(handler: AfterResolveHandler<unknown, Record>): void;
+export declare function registerAfterResolve<A, D extends Record>(_this: Resolvable<A, D>, handler: AfterResolveHandler<A, D>): void;
+export { assertInResolutionContext, getCurrentResolutionContext, runInResolutionContext };

package/injector/resolution.js

@@ -0,0 +1,6 @@
+import { createContextProvider } from '../context/index.js';
+const { assertInResolutionContext, getCurrentResolutionContext, runInResolutionContext } = createContextProvider('Resolution');
+export function registerAfterResolve(thisOrHandler, handlerOrNothing) {
+    getCurrentResolutionContext(true, registerAfterResolve).afterResolveRegistrations.push(handlerOrNothing ?? thisOrHandler);
+}
+export { assertInResolutionContext, getCurrentResolutionContext, runInResolutionContext };

package/logger/console/logger.d.ts

@@ -7,5 +7,5 @@ export declare class ConsoleLogger extends Logger {
     fork(options: LoggerForkOptions): ConsoleLogger;
     subModule(subModule: string): ConsoleLogger;
     prefix(prefix: string): ConsoleLogger;
-    protected log(level: LogLevel, entryOrError: string | Error, errorOptions?: LogErrorOptions): void;
+    protected log(level: LogLevel, entryOrError: string | unknown, errorOptions?: LogErrorOptions): void;
 }

package/logger/logger.d.ts

@@ -26,8 +26,8 @@ export declare abstract class Logger implements Resolvable<LoggerArgument> {
     readonly logPrefix: string;
     readonly [resolveArgumentType]: LoggerArgument;
     constructor(level: LogLevel, module?: string | string[], prefix?: string);
-    error(error: Error, options?: LogErrorOptions): void;
     error(entry: LogEntryOrProvider): void;
+    error(error: unknown, options?: LogErrorOptions): void;
     warn(entry: LogEntryOrProvider): void;
     info(entry: LogEntryOrProvider): void;
     verbose(entry: LogEntryOrProvider): void;

package/mail/drizzle.config.js

@@ -5,7 +5,7 @@ export default defineConfig({
     out: relative('./', resolve(__dirname, './drizzle/').replace('dist', 'source')),
     schema: resolve(__dirname, './models/schemas.js'),
     migrations: {
-        schema: 'authentication',
+        schema: 'mail',
         table: '_migrations'
     }
 });

package/mail/models/schemas.d.ts

@@ -1,3 +1,3 @@
 import { MailLog } from './mail-log.model.js';
 export declare const mailSchema: import("../../orm/server/database-schema.js").DatabaseSchema<"mail">;
-export declare const mailLog: import("../../orm/server/types.js").PgTableFromType<"mail", typeof MailLog>;
+export declare const mailLog: import("../../orm/server/types.js").PgTableFromType<typeof MailLog, "mail">;

package/object-storage/object-storage.d.ts

@@ -21,13 +21,6 @@ export declare abstract class ObjectStorage implements Resolvable<ObjectStorageA
      * @param content content of object
      */
     abstract uploadObject(key: string, content: Uint8Array | ReadableStream<Uint8Array>, options?: UploadObjectOptions): Promise<void>;
-    /**
-     * Uploads an object stream
-     * @param key object key
-     * @param stream stream of object
-     * @deprecated use {@link uploadObject} instead
-     */
-    abstract uploadObjectStream(key: string, stream: ReadableStream<Uint8Array>, options?: UploadObjectOptions): Promise<void>;
     /**
      * Get an url which can be used to upload the object without further authorization
      * @param key object key
@@ -52,6 +45,11 @@ export declare abstract class ObjectStorage implements Resolvable<ObjectStorageA
      * @param key object key
      */
     abstract getResourceUri(key: string): Promise<string>;
+    /**
+     * Get object content
+     * @param key object key
+     */
+    abstract getContent(key: string): Promise<Uint8Array>;
     /**
      * Get stream of object content
      * @param key object key

package/object-storage/s3/s3.object-storage.d.ts

@@ -12,7 +12,6 @@ export declare class S3ObjectStorage extends ObjectStorage {
     exists(key: string): Promise<boolean>;
     statObject(key: string): Promise<BucketItemStat>;
     uploadObject(key: string, content: Uint8Array | ReadableStream<Uint8Array>, options?: UploadObjectOptions): Promise<void>;
-    uploadObjectStream(key: string, stream: ReadableStream<Uint8Array>, options?: UploadObjectOptions): Promise<void>;
     getContent(key: string): Promise<Uint8Array>;
     getContentStream(key: string): ReadableStream<Uint8Array>;
     getObjects(): Promise<S3Object[]>;

package/object-storage/s3/s3.object-storage.js

@@ -66,9 +66,6 @@ let S3ObjectStorage = class S3ObjectStorage extends ObjectStorage {
             ]);
         }
     }
-    async uploadObjectStream(key, stream, options) {
-        return this.uploadObject(key, stream, options);
-    }
     async getContent(key) {
         const bucketKey = this.getBucketKey(key);
         const result = await this.client.getObject(this.bucket, bucketKey);

package/orm/{server/data-types → data-types}/numeric-date.js

@@ -1,12 +1,11 @@
 import { customType } from 'drizzle-orm/pg-core';
-import { dateToNumericDate, numericDateToDate } from '../../../utils/date-time.js';
+import { dateToNumericDate, numericDateToDate } from '../../utils/date-time.js';
 export const numericDate = customType({
     dataType() {
         return 'date';
     },
     toDriver(value) {
-        const { year, month, day } = numericDateToDate(value);
-        return new Date(year, month - 1, day).toISOString();
+        return numericDateToDate(value).toISOString();
     },
     fromDriver(value) {
         const date = new Date(value);

package/orm/decorators.d.ts

@@ -4,16 +4,16 @@ import type { AbstractConstructor, TypedOmit } from '../types.js';
 import type { Entity, EntityType } from './entity.js';
 import type { PgTableFromType } from './server/types.js';
 type IndexMethod = LiteralUnion<'hash' | 'btree' | 'gist' | 'spgist' | 'gin' | 'brin' | 'hnsw' | 'ivfflat', string>;
-export type CheckBuilder<T extends Entity = any> = (table: PgTableFromType<string, EntityType<T>>) => SQL;
+type NamingStrategy = 'abbreviated-table';
+export type CheckBuilder<T extends Entity = any> = (table: PgTableFromType<EntityType<T>>) => SQL;
 export type OrmTableReflectionData = {
     name?: string;
     schema?: string;
+    compundPrimaryKeyName?: string;
+    compundPrimaryKeyNaming?: NamingStrategy;
     unique?: UniqueReflectionData[];
     index?: IndexReflectionData[];
-    checks?: {
-        name: string;
-        builder: CheckBuilder;
-    }[];
+    checks?: CheckReflectionData[];
 };
 export type OrmColumnReflectionData = {
     name?: string;
@@ -35,6 +35,7 @@ export type UniqueReflectionData = {
     columns?: string[];
     options?: {
         nulls?: 'distinct' | 'not distinct';
+        naming?: NamingStrategy;
     };
 };
 export type IndexReflectionData = {
@@ -45,6 +46,14 @@ export type IndexReflectionData = {
         using?: IndexMethod;
         unique?: boolean;
         nulls?: 'first' | 'last';
+        naming?: NamingStrategy;
+    };
+};
+type CheckReflectionData = {
+    name: string;
+    builder: CheckBuilder;
+    options?: {
+        naming?: NamingStrategy;
     };
 };
 export declare function createTableDecorator(data?: OrmTableReflectionData): ClassDecorator;
@@ -60,9 +69,9 @@ type TableOptions = Partial<Pick<OrmTableReflectionData, 'name' | 'schema'>>;
 export declare function Table(name?: string, options?: TypedOmit<TableOptions, 'schema'>): ClassDecorator;
 export declare function Table(options?: TableOptions): ClassDecorator;
 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 declare function Unique(columns: [string, ...string[]], options?: UniqueReflectionData['options']): ClassDecorator;
+export declare function Unique<T>(name: string | undefined, columns: [Extract<keyof T, string>, ...Extract<keyof T, string>[]], options?: UniqueReflectionData['options']): ClassDecorator;
+export declare function Unique<T>(columns: [Extract<keyof T, string>, ...Extract<keyof T, string>[]], options?: UniqueReflectionData['options']): ClassDecorator;
 export declare function Index(name?: string, options?: IndexReflectionData['options']): PropertyDecorator;
-export declare function Index(name: string | undefined, columns: [string, ...string[]], options?: IndexReflectionData['options']): ClassDecorator;
+export declare function Index(name: string, columns: [string, ...string[]], options?: IndexReflectionData['options']): ClassDecorator;
 export declare function Index(columns: [string, ...string[]], options?: IndexReflectionData['options']): ClassDecorator;
 export {};

package/orm/decorators.js

@@ -1,20 +1,23 @@
 import { createClassDecorator, createDecorator, createPropertyDecorator } from '../reflection/index.js';
 import { Property } from '../schema/index.js';
-import { objectEntries } from '../utils/object/object.js';
+import { filterUndefinedObjectProperties, objectEntries } from '../utils/object/object.js';
 import { assertNotArrayPass, isArray, isString, isUndefined } from '../utils/type-guards.js';
 export function createTableDecorator(data = {}) {
     return createClassDecorator({
         handler: (_, metadata) => {
             const reflectionData = metadata.data.tryGet('orm') ?? {};
             const dataEntries = objectEntries(data);
+            if (dataEntries.length == 0) {
+                return;
+            }
             for (const [key, value] of dataEntries) {
                 const existingValue = reflectionData[key];
-                if (isUndefined(existingValue)) {
-                    reflectionData[key] = value;
-                }
-                else if (isArray(existingValue)) {
+                if (isArray(existingValue)) {
                     reflectionData[key] = [...existingValue, ...value];
                 }
+                else {
+                    reflectionData[key] = value;
+                }
             }
             metadata.data.set('orm', reflectionData, true);
         }
@@ -49,7 +52,10 @@ export function Embedded(type, options) {
 export function Table(nameOrOptions, optionsOrNothing) {
     const name = isString(nameOrOptions) ? nameOrOptions : nameOrOptions?.name;
     const schema = isString(nameOrOptions) ? optionsOrNothing?.schema : nameOrOptions?.schema;
-    return createTableDecorator({ name, schema });
+    const data = (isUndefined(name) && isUndefined(schema))
+        ? undefined
+        : filterUndefinedObjectProperties({ name, schema });
+    return createTableDecorator(data);
 }
 export function Unique(nameOrColumns, columnsOrOptions, options) {
     if (isArray(nameOrColumns)) {
@@ -58,7 +64,7 @@ export function Unique(nameOrColumns, columnsOrOptions, options) {
     if (isArray(columnsOrOptions)) {
         return createTableDecorator({ unique: [{ name: nameOrColumns, columns: columnsOrOptions, options }] });
     }
-    return createColumnDecorator({ unique: { name: nameOrColumns, options: columnsOrOptions ?? options } });
+    return createColumnDecorator({ unique: { name: nameOrColumns, options: columnsOrOptions } });
 }
 export function Index(nameOrColumns, columnsOrOptions, options) {
     if (isArray(nameOrColumns)) {

package/orm/entity.d.ts

@@ -1,13 +1,8 @@
-import type { Type, TypedOmit } from '../types.js';
-import type { UntaggedDeep } from '../types/index.js';
+import type { Type } from '../types.js';
 import { Embedded, type HasDefault, type IsPrimaryKey, Json, Timestamp, Uuid } from './types.js';
-export interface EntityType<T extends Entity = Entity> extends Type<T> {
+export interface EntityType<T extends Entity | EntityWithoutMetadata = Entity | EntityWithoutMetadata> extends Type<T> {
     readonly entityName?: string;
 }
-export type NewEntity<T extends Entity> = UntaggedDeep<TypedOmit<T, 'id' | 'metadata'> & {
-    id?: string;
-    metadata?: Partial<Pick<EntityMetadata, 'attributes'>>;
-}>;
 export declare abstract class EntityMetadataAttributes {
     [key: string]: unknown;
 }
@@ -22,3 +17,6 @@ export declare abstract class Entity {
     id: IsPrimaryKey<HasDefault<Uuid>>;
     metadata: Embedded<EntityMetadata>;
 }
+export declare abstract class EntityWithoutMetadata {
+    id: IsPrimaryKey<HasDefault<Uuid>>;
+}

package/orm/entity.js

@@ -8,7 +8,7 @@ var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
 import { Defaulted, Integer } from '../schema/index.js';
-import { Index, PrimaryKey } from './decorators.js';
+import { PrimaryKey } from './decorators.js';
 import { Embedded, Json, Timestamp, Uuid } from './types.js';
 let EntityMetadataAttributes = class EntityMetadataAttributes {
 };
@@ -16,13 +16,13 @@ EntityMetadataAttributes = __decorate([
     Json()
 ], EntityMetadataAttributes);
 export { EntityMetadataAttributes };
-let EntityMetadata = class EntityMetadata {
+export class EntityMetadata {
     revision;
     revisionTimestamp;
     createTimestamp;
     deleteTimestamp;
     attributes;
-};
+}
 __decorate([
     Integer(),
     __metadata("design:type", Number)
@@ -43,10 +43,6 @@ __decorate([
     Defaulted(EntityMetadataAttributes, {}),
     __metadata("design:type", Object)
 ], EntityMetadata.prototype, "attributes", void 0);
-EntityMetadata = __decorate([
-    Index(undefined, ['revision', 'revisionTimestamp'])
-], EntityMetadata);
-export { EntityMetadata };
 export class Entity {
     id;
     metadata;
@@ -60,3 +56,11 @@ __decorate([
     Embedded(EntityMetadata, { prefix: null }),
     __metadata("design:type", Object)
 ], Entity.prototype, "metadata", void 0);
+export class EntityWithoutMetadata {
+    id;
+}
+__decorate([
+    PrimaryKey(),
+    Uuid({ defaultRandom: true }),
+    __metadata("design:type", Object)
+], EntityWithoutMetadata.prototype, "id", void 0);

package/orm/index.d.ts

@@ -1,3 +1,5 @@
 export * from './entity.js';
 export * from './query.js';
+export * from './repository.types.js';
 export * from './types.js';
+export * from './utils.js';

package/orm/index.js

@@ -1,3 +1,5 @@
 export * from './entity.js';
 export * from './query.js';
+export * from './repository.types.js';
 export * from './types.js';
+export * from './utils.js';

package/orm/query.d.ts

@@ -19,8 +19,6 @@ export type Query<T = any> = SQLWrapper | QueryObject<T>;
 export type QueryObject<T> = LogicalQuery<T> | (ComparisonQueryBody<T> & SpecialQuery<T>);
 export type QueryTypes = LogicalQueryTypes | ComparisonQueryTypes | SpecialQueryTypes;
 export declare const allQueryTypes: ("$and" | "$or" | "$nor" | "$not" | "$eq" | "$neq" | "$exists" | "$item" | "$in" | "$nin" | "$all" | "$gt" | "$gte" | "$lt" | "$lte" | "$regex" | "$text" | "$geoShape" | "$geoDistance" | "$textSpan")[];
-export type Order = 'asc' | 'desc';
-export declare const allOrders: Order[];
 export type Operator = 'and' | 'or';
 export declare const allOperators: Operator[];
 export type LogicalAndQuery<T = any> = {
@@ -32,7 +30,7 @@ export type LogicalOrQuery<T = any> = {
 export type LogicalNorQuery<T = any> = {
     $nor: readonly Query<T>[];
 };
-export type ComparisonValue<T> = Untagged<T | Flatten<T>>;
+export type ComparisonValue<T> = Untagged<T | Flatten<T>> | SQLWrapper;
 export type ComparisonValueWithRegex<T> = T extends string ? ComparisonValue<T | RegExp> : T extends readonly string[] ? ComparisonValue<readonly (Flatten<T> | RegExp)[]> : (T | Flatten<T>);
 export type ComparisonNotQuery<T = any> = {
     $not: ComparisonQuery<T>;