@tstdl/base 0.92.122 → 0.92.124

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

@@ -0,0 +1,2 @@
+export * from './ai-validation-executor.js';
+export * from './validator.js';

package/document-management/server/validators/single-document-validation-executor.js

@@ -0,0 +1,20 @@
+import { DocumentValidationResultStatus } from '../../../document-management/models/document-validation-execution.model.js';
+import { boolean, object, optional, string } from '../../../schema/index.js';
+import { AiValidationDifficulty, AiValidationExecutor } from './ai-validation-executor.js';
+export class SingleDocumentValidationExecutor extends AiValidationExecutor {
+    identifier = 'single-document';
+    difficulty = AiValidationDifficulty.MediumLow;
+    schema = object({
+        hasMultipleDocuments: boolean(),
+        reason: optional(string()),
+    });
+    getPrompt() {
+        return 'Überprüfe ob das Dokument aus mehreren Dokumenten zusammengesetzt ist. Falls ja, begründe in wenigen Worten. Antworte auf deutsch.';
+    }
+    getResult(output) {
+        if (output.hasMultipleDocuments) {
+            return { status: DocumentValidationResultStatus.Warning, message: output.reason ?? null };
+        }
+        return { status: DocumentValidationResultStatus.Passed };
+    }
+}

package/document-management/server/validators/validator.js

@@ -0,0 +1,2 @@
+export class DocumentValidationExecutor {
+}

package/eslint.config.js

@@ -12,25 +12,24 @@ export default [
       parser: tsParser,
       parserOptions: {
         projectService: {
-          allowDefaultProject: ['*.js']
-        }
+          allowDefaultProject: ['*.js'],
+        },
       },
-      globals: { ...globals.browser, ...globals.node }
-    }
+      globals: { ...globals.browser, ...globals.node },
+    },
   },
   stylistic.configs.customize({
     semi: true,
     arrowParens: true,
-    commaDangle: 'never'
   }),
   {
     rules: {
-      'prefer-named-capture-group': ['warn']
-    }
+      'prefer-named-capture-group': ['warn'],
+    },
   },
   {
     plugins: {
-      '@typescript-eslint': tseslint
+      '@typescript-eslint': tseslint,
     },
     rules: {
       ...tseslint.configs['strict-type-checked'].rules,
@@ -48,24 +47,39 @@ export default [
       '@typescript-eslint/no-unsafe-assignment': 'off',
       '@typescript-eslint/no-unused-vars': ['warn', { varsIgnorePattern: '^_', argsIgnorePattern: '^_' }],
       '@typescript-eslint/promise-function-async': 'error',
-      '@typescript-eslint/restrict-template-expressions': ['warn', { allowNumber: true, allowBoolean: true, allowNullish: true }]
-    }
+      '@typescript-eslint/restrict-template-expressions': ['warn', { allowNumber: true, allowBoolean: true, allowNullish: true }],
+    },
   },
   {
     rules: {
       '@stylistic/member-delimiter-style': ['warn', {
-        multiline: { delimiter: 'comma', requireLast: false },
+        multiline: { delimiter: 'comma', requireLast: true },
         singleline: { delimiter: 'comma', requireLast: false },
         overrides: {
           interface: {
             multiline: { delimiter: 'semi', requireLast: true },
-            singleline: { delimiter: 'semi', requireLast: true }
-          }
-        }
+            singleline: { delimiter: 'semi', requireLast: true },
+          },
+        },
       }],
       '@stylistic/yield-star-spacing': ['warn', 'after'],
       '@stylistic/generator-star-spacing': ['warn', 'before'],
-      '@stylistic/indent': 'off'
-    }
-  }
+      '@stylistic/indent': 'off',
+      '@stylistic/comma-dangle': [
+        'error',
+        {
+          arrays: 'always-multiline',
+          objects: 'always-multiline',
+          imports: 'always-multiline',
+          exports: 'always-multiline',
+          functions: 'only-multiline',
+          importAttributes: 'always-multiline',
+          dynamicImports: 'always-multiline',
+          enums: 'always-multiline',
+          generics: 'always-multiline',
+          tuples: 'always-multiline',
+        },
+      ],
+    },
+  },
 ];

package/examples/document-management/main.js

@@ -6,16 +6,31 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 };
 import '../../polyfills.js';
 import { Application } from '../../application/application.js';
-import { DocumentManagementAncillaryService } from '../../document-management/server/index.js';
+import { DocumentCategoryTypeService, DocumentCollectionService, DocumentManagementAncillaryService, DocumentRequestService } 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 { injectManyAsync } 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']);
+    _resolveMetadata(collections) {
+        return collections.map((collection) => ({ name: collection.metadata.attributes['name'], group: null }));
     }
+    canReadCollection(_collectionId, _token) { return true; }
+    canWriteCollection(_collectionId, _token) { return true; }
+    canApproveDocument(_documentId, _token) { return true; }
+    canRejectDocument(_documentId, _token) { return true; }
+    canReadDocumentRequest(_requestId, _token) { return true; }
+    canAssignDocumentToRequest(_requestId, _documentId, _token) { return true; }
+    canManageCategoriesAndTypes(_token) { return true; }
+    canReadDocumentRequestsTemplates(_token) { return true; }
+    canManageDocumentRequestsTemplates(_token) { return true; }
+    canCreateUnassignedDocument(_token) { return true; }
+    canCreateRequestAssignedDocument(_token) { return true; }
+    canDeleteDocument(_documentId, _token) { return true; }
+    canManageDocumentRequest(_token) { return true; }
+    canManageValidationDefinitions(_token) { return true; }
+    canProgressDocumentWorkflow(_documentId, _currentWorkflowStep, _token) { return true; }
 };
 TestDocumentManagementAncillaryService = __decorate([
     Singleton()
@@ -25,23 +40,24 @@ async function bootstrap() {
     configureDocumentManagement({
         ancillaryService: TestDocumentManagementAncillaryService,
         fileObjectStorageModule: 'documents',
+        filePreviewObjectStorageModule: 'document-previews',
         database: {
             connection: {
                 database: 'xxx',
                 user: 'xxx',
-                password: 'xxx'
-            }
-        }
+                password: 'xxx',
+            },
+        },
     });
     configureS3ObjectStorage({ endpoint: 'http://localhost:10000', accessKey: 'tstdl-dev', secretKey: 'tstdl-dev', bucketPerModule: true });
     await migrateDocumentManagementSchema();
 }
 async function main() {
-    const documentManagementService = await injectAsync(DocumentManagementService);
-    const collection = await documentManagementService.createCollection();
-    const category = await documentManagementService.createCategory({ label: 'Testkategorie' });
-    const type = await documentManagementService.createType({ categoryId: category.id, group: null, label: 'Testtyp' });
-    const request = await documentManagementService.createDocumentRequest({ typeId: type.id, requiredFilesCount: 1, comment: null, collectionIds: [collection.id] });
+    const [documentManagementService, documentCollectionService, documentCategoryTypeService, documentRequestService] = await injectManyAsync(DocumentManagementService, DocumentCollectionService, DocumentCategoryTypeService, DocumentRequestService);
+    const collection = await documentCollectionService.createCollection(null);
+    const category = await documentCategoryTypeService.createCategory('Testkategorie', null);
+    const type = await documentCategoryTypeService.createType('Testtyp', category.id);
+    const request = await documentRequestService.createRequest(type.id, [collection.id], null);
     const data = await documentManagementService.loadData([collection.id]);
     console.log(data);
 }

package/file/mime-type.js

@@ -12,16 +12,9 @@ export function getMimeTypeExtensions(mimeType) {
 async function spawnFileCommand(args, file) {
     const process = await spawnCommand('file', args);
     if (isDefined(file)) {
-        try {
-            await process.write(file);
-        }
-        catch { /* ignore as file command closes stdin early */ }
-    }
-    const { code } = await process.wait();
-    if (code != 0) {
-        const errorOutput = await process.readError();
-        throw new Error(errorOutput.trim());
+        process.autoWrite(file);
     }
+    await process.wait({ throwOnNonZeroExitCode: true });
     const output = await process.readOutput();
     if (output.includes('file or directory')) {
         throw new Error(output.trim());

package/formats.js

@@ -7,35 +7,35 @@ export function configureFormats(options) {
 }
 export const integerFormat = {
     useGrouping: true,
-    maximumFractionDigits: 0
+    maximumFractionDigits: 0,
 };
 export const decimalFormat = {
     useGrouping: true,
     minimumFractionDigits: 2,
-    maximumFractionDigits: 2
+    maximumFractionDigits: 2,
 };
 export const decimal1Format = {
     useGrouping: true,
     minimumFractionDigits: 0,
-    maximumFractionDigits: 1
+    maximumFractionDigits: 1,
 };
 export const yearFormat = {
     useGrouping: false,
-    maximumFractionDigits: 0
+    maximumFractionDigits: 0,
 };
 export const dateTimeNumeric = {
     year: 'numeric',
     month: '2-digit',
     day: '2-digit',
     hour: '2-digit',
-    minute: '2-digit'
+    minute: '2-digit',
 };
 export const dateTimeShort = {
     year: 'numeric',
     month: 'short',
     day: '2-digit',
     hour: '2-digit',
-    minute: '2-digit'
+    minute: '2-digit',
 };
 export const dateTimeLong = {
     year: 'numeric',
@@ -43,48 +43,48 @@ export const dateTimeLong = {
     month: 'long',
     day: '2-digit',
     hour: '2-digit',
-    minute: '2-digit'
+    minute: '2-digit',
 };
 export const dateShort = {
     year: 'numeric',
     month: '2-digit',
-    day: '2-digit'
+    day: '2-digit',
 };
 export const dateMedium = {
     year: 'numeric',
     month: 'long',
-    day: '2-digit'
+    day: '2-digit',
 };
 export const dateLong = {
     year: 'numeric',
     weekday: 'long',
     month: 'long',
-    day: '2-digit'
+    day: '2-digit',
 };
 export const timeShort = {
     hour: '2-digit',
-    minute: '2-digit'
+    minute: '2-digit',
 };
-export const euroFormat = {
+export const currencyFormat = {
     style: 'currency',
-    currency: 'EUR'
 };
-export const euroFormatWithoutCents = {
-    ...euroFormat,
-    minimumFractionDigits: 0
+export const currencyFormatWithoutCents = {
+    ...currencyFormat,
+    minimumFractionDigits: 0,
 };
 export const percentFormat = {
     style: 'percent',
     minimumFractionDigits: 2,
-    maximumFractionDigits: 2
+    maximumFractionDigits: 2,
 };
 const getDecimalFormatter = memoize(_getDecimalFormatter);
-const dateFormatter = memoizeSingle((loc) => Intl.DateTimeFormat(loc, dateShort));
 const integerFormatter = memoizeSingle((loc) => Intl.NumberFormat(loc, integerFormat));
 const decimalFormatter = memoizeSingle((loc) => Intl.NumberFormat(loc, decimalFormat));
 const yearFormatter = memoizeSingle((loc) => Intl.NumberFormat(loc, yearFormat));
-const euroFormatter = memoizeSingle((loc) => Intl.NumberFormat(loc, euroFormat));
 const percentFormatter = memoizeSingle((loc) => Intl.NumberFormat(loc, percentFormat));
+const dateFormatter = memoizeSingle((loc) => Intl.DateTimeFormat(loc, dateShort));
+const currencyFormatter = memoize((currency, loc) => Intl.NumberFormat(loc, { ...currencyFormat, currency }));
+const currencyFormatterWithoutCents = memoize((currency, loc) => Intl.NumberFormat(loc, { ...currencyFormatWithoutCents, currency }));
 const timeShortFormatter = memoizeSingle((loc) => Intl.DateTimeFormat(loc, timeShort));
 const dateShortFormatter = memoizeSingle((loc) => Intl.DateTimeFormat(loc, dateShort));
 export function formatNumber(value, format) {
@@ -97,7 +97,7 @@ export function formatDecimal(value, minimumFractionDigits, maximumFractionDigit
     if (isUndefined(minimumFractionDigits) && isUndefined(maximumFractionDigits)) {
         return decimalFormatter(locale).format(value);
     }
-    return getDecimalFormatter(minimumFractionDigits ?? 2, maximumFractionDigits ?? 2).format(value);
+    return getDecimalFormatter(locale, minimumFractionDigits ?? 2, maximumFractionDigits ?? 2).format(value);
 }
 export function formatYear(value) {
     return yearFormatter(locale).format(value);
@@ -114,8 +114,17 @@ export function formatDate(dateOrTimestamp) {
 export function formatNumericDate(numericDate) {
     return formatDate(numericDateToTimestamp(numericDate));
 }
+export function formatCurrency(value, currency) {
+    return currencyFormatter(currency, locale).format(value);
+}
+export function formatCurrencyWithoutCents(value, currency) {
+    return currencyFormatterWithoutCents(currency, locale).format(value);
+}
 export function formatEuro(value) {
-    return euroFormatter(locale).format(value);
+    return currencyFormatter('EUR', locale).format(value);
+}
+export function formatEuroWithoutCents(value) {
+    return currencyFormatterWithoutCents('EUR', locale).format(value);
 }
 export function formatPercent(value) {
     return percentFormatter(locale).format(value);
@@ -133,10 +142,10 @@ export function formatPersonName(person, { lastNameFirst = false, fallback } = {
  * @deprecated use {@link formatPersonName} instead
  */
 export const formatUserName = formatPersonName;
-function _getDecimalFormatter(minimumFractionDigits = 2, maximumFractionDigits = 2) {
+function _getDecimalFormatter(locale, minimumFractionDigits = 2, maximumFractionDigits = 2) {
     return Intl.NumberFormat(locale, {
         useGrouping: true,
         minimumFractionDigits,
-        maximumFractionDigits
+        maximumFractionDigits,
     });
 }

package/http/client/http-client.js

@@ -14,7 +14,7 @@ import { encodeBase64 } from '../../utils/base64.js';
 import { encodeUtf8 } from '../../utils/encoding.js';
 import { composeAsyncMiddleware } from '../../utils/middleware.js';
 import { objectEntries } from '../../utils/object/object.js';
-import { readableStreamFromPromise } from '../../utils/stream/readable-stream-from-promise.js';
+import { readableStreamFromPromise } from '../../utils/stream/from-promise.js';
 import { assertDefined, isArray, isBlob, isDefined, isObject, isUndefined } from '../../utils/type-guards.js';
 import { buildUrl } from '../../utils/url-builder.js';
 import { HttpHeaders } from '../http-headers.js';

package/injector/injector.js

@@ -209,8 +209,8 @@ export class Injector {
         this.assertNotDisposed();
         if (isDefined(options.forwardRef) && (options.forwardRef != false)) {
             assert(options.optional != true, 'ForwardRef does not support optional without resolveAll/injectAll as undefined is not forwardable.');
-            const forwardRef = ForwardRef.create();
             const forwardToken = isFunction(options.forwardRef) ? options.forwardRef() : token;
+            const forwardRef = ForwardRef.create({ typeHint: (options.forwardRefTypeHint ?? isFunction(forwardToken)) ? forwardToken : undefined });
             context.forwardRefQueue.add(() => ForwardRef.setRef(forwardRef, this._resolve(forwardToken, argument, { ...options, forwardRef: false }, context, chain.markAsForwardRef(forwardToken))));
             context.forwardRefs.add(forwardRef);
             return forwardRef;
@@ -234,8 +234,8 @@ export class Injector {
     _resolveAll(token, argument, options, context, chain) {
         this.assertNotDisposed();
         if (isDefined(options.forwardRef) && (options.forwardRef != false)) {
-            const forwardRef = ForwardRef.create({ typeHint: options.forwardRefTypeHint });
             const forwardToken = isFunction(options.forwardRef) ? options.forwardRef() : token;
+            const forwardRef = ForwardRef.create({ typeHint: (options.forwardRefTypeHint ?? isFunction(forwardToken)) ? forwardToken : undefined });
             context.forwardRefQueue.add(() => ForwardRef.setRef(forwardRef, this._resolveAll(forwardToken, argument, { ...options, forwardRef: false }, context, chain.markAsForwardRef(forwardToken))));
             context.forwardRefs.add(forwardRef);
             return forwardRef;

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

@@ -62,7 +62,7 @@ let S3ObjectStorage = class S3ObjectStorage extends ObjectStorage {
             const errorPromise = new Promise((_, reject) => readable.on('error', reject));
             await Promise.race([
                 this.client.putObject(this.bucket, bucketKey, readable, options?.contentLength, options?.metadata),
-                errorPromise
+                errorPromise,
             ]);
         }
     }

package/orm/data-types/bytea.js

@@ -1,4 +1,12 @@
+/**
+ * @module
+ * Defines a custom Drizzle type for handling PostgreSQL `bytea` columns.
+ */
 import { customType } from 'drizzle-orm/pg-core';
+/**
+ * Custom Drizzle type for PostgreSQL `bytea` columns.
+ * Maps between `Uint8Array` in JavaScript and `bytea` in the database.
+ */
 export const bytea = customType({
     dataType() {
         return 'bytea';

package/orm/data-types/index.js

@@ -1,3 +1,7 @@
+/**
+ * @module
+ * Exports custom Drizzle data types for PostgreSQL.
+ */
 export * from './bytea.js';
 export * from './numeric-date.js';
 export * from './timestamp.js';

package/orm/data-types/numeric-date.js

@@ -1,5 +1,14 @@
+/**
+ * @module
+ * Defines a custom Drizzle type for handling PostgreSQL `date` columns
+ * using numeric representation (YYYYMMDD).
+ */
 import { customType } from 'drizzle-orm/pg-core';
 import { dateToNumericDate, numericDateToDate } from '../../utils/date-time.js';
+/**
+ * Custom Drizzle type for PostgreSQL `date` columns, storing dates as numeric values (YYYYMMDD).
+ * Converts between JavaScript `number` (YYYYMMDD) and database `date` (ISO string).
+ */
 export const numericDate = customType({
     dataType() {
         return 'date';

package/orm/data-types/timestamp.js

@@ -1,4 +1,13 @@
+/**
+ * @module
+ * Defines a custom Drizzle type for handling PostgreSQL `timestamp with time zone` columns
+ * using numeric representation (Unix timestamp in milliseconds).
+ */
 import { customType } from 'drizzle-orm/pg-core';
+/**
+ * Custom Drizzle type for PostgreSQL `timestamp with time zone` columns, storing timestamps as numeric values (Unix timestamp in milliseconds).
+ * Converts between JavaScript `number` (milliseconds since epoch) and database `timestamp with time zone` (ISO string).
+ */
 export const timestamp = customType({
     dataType() {
         return 'timestamp with time zone';

package/orm/decorators.js

@@ -2,6 +2,12 @@ import { createClassDecorator, createDecorator, createPropertyDecorator } from '
 import { Property } from '../schema/index.js';
 import { filterUndefinedObjectProperties, objectEntries } from '../utils/object/object.js';
 import { assertNotArrayPass, isArray, isString, isUndefined } from '../utils/type-guards.js';
+/**
+ * Factory function to create a class decorator for ORM table configuration.
+ * Merges provided data with existing ORM reflection data on the class metadata.
+ * @param data - The ORM table reflection data to add.
+ * @returns A class decorator.
+ */
 export function createTableDecorator(data = {}) {
     return createClassDecorator({
         handler: (_, metadata) => {
@@ -23,27 +29,71 @@ export function createTableDecorator(data = {}) {
         }
     });
 }
+/**
+ * Factory function to create a property decorator for ORM column configuration.
+ * Merges provided data with existing ORM reflection data on the property metadata.
+ * @param data - The ORM column reflection data to add.
+ * @returns A property decorator.
+ */
 export function createColumnDecorator(data) {
     return createPropertyDecorator({ data: { orm: data }, mergeData: true });
 }
+/**
+ * Factory function to create a decorator applicable to both classes and properties for ORM configuration.
+ * Merges provided data with existing ORM reflection data on the target's metadata.
+ * @param data - The ORM reflection data to add.
+ * @returns A class or property decorator.
+ */
 export function createTableAndColumnDecorator(data) {
     return createDecorator({ class: true, property: true, data: { orm: data }, mergeData: true });
 }
+/**
+ * Decorator to specify ORM column options.
+ * @param options - Column configuration options.
+ * @returns A property decorator.
+ */
 export function Column(options) {
     return createColumnDecorator({ ...options });
 }
+/**
+ * Decorator to mark a property as the primary key column.
+ * @returns A property decorator.
+ */
 export function PrimaryKey() {
     return createColumnDecorator({ primaryKey: true });
 }
+/**
+ * Decorator to define a foreign key relationship.
+ * @param type - A function returning the referenced entity type.
+ * @returns A property decorator.
+ */
 export function References(type) {
     return createColumnDecorator({ references: type });
 }
+/**
+ * Decorator to define a table check constraint.
+ * @template T - The entity type.
+ * @param name - The name of the check constraint.
+ * @param builder - A function to build the SQL check expression.
+ * @returns A class decorator.
+ */
 export function Check(name, builder) {
     return createTableDecorator({ checks: [{ name, builder }] });
 }
+/**
+ * Decorator to mark a column for encryption.
+ * The underlying database type will typically be `bytea`.
+ * @returns A property decorator.
+ */
 export function Encrypted() {
     return createColumnDecorator({ encrypted: true });
 }
+/**
+ * Decorator to embed another class's properties into the current entity's table.
+ * @param type - The constructor of the class to embed.
+ * @param options - Embedding options, like prefixing column names.
+ * @returns A property decorator.
+ */
 export function Embedded(type, options) {
     return createPropertyDecorator({
         include: [Property(type), createColumnDecorator({ embedded: { type, ...options } })]

package/orm/entity.js

@@ -7,15 +7,26 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
+/**
+ * @module
+ * Defines base entity classes and related types for the ORM.
+ */
 import { Defaulted, Integer } from '../schema/index.js';
 import { PrimaryKey } from './decorators.js';
 import { Embedded, Json, Timestamp, Uuid } from './types.js';
+/**
+ * Base class for extensible metadata attributes associated with an entity.
+ * Allows storing arbitrary key-value pairs.
+ */
 let EntityMetadataAttributes = class EntityMetadataAttributes {
 };
 EntityMetadataAttributes = __decorate([
     Json()
 ], EntityMetadataAttributes);
 export { EntityMetadataAttributes };
+/**
+ * Base class defining common metadata fields for entities, such as revision tracking and timestamps.
+ */
 export class EntityMetadata {
     revision;
     revisionTimestamp;
@@ -43,6 +54,10 @@ __decorate([
     Defaulted(EntityMetadataAttributes, {}),
     __metadata("design:type", Object)
 ], EntityMetadata.prototype, "attributes", void 0);
+/**
+ * Abstract base class for entities that include standard metadata.
+ * Provides a default `id` (UUID primary key) and an `metadata` field.
+ */
 export class Entity {
     id;
     metadata;
@@ -56,6 +71,10 @@ __decorate([
     Embedded(EntityMetadata, { prefix: null }),
     __metadata("design:type", Object)
 ], Entity.prototype, "metadata", void 0);
+/**
+ * Abstract base class for entities that do *not* include the standard metadata fields.
+ * Provides only a default `id` (UUID primary key). Useful for simpler tables or join tables.
+ */
 export class EntityWithoutMetadata {
     id;
 }

package/orm/index.js

@@ -1,3 +1,8 @@
+/**
+ * @module
+ * Barrel file exporting core ORM functionalities including data types,
+ * base entities, query types, repository types, SQL helpers, and utility types.
+ */
 export * from './data-types/index.js';
 export * from './entity.js';
 export * from './query.js';

package/orm/query.js

@@ -1,6 +1,12 @@
+/** Array containing all valid logical query operator keys. */
 export const allLogicalQueryTypes = ['$and', '$or', '$nor'];
+/** Array containing all valid comparison query operator keys. */
 export const allComparisonQueryTypes = ['$all', '$not', '$eq', '$exists', '$gt', '$gte', '$in', '$item', '$lt', '$lte', '$neq', '$nin', '$regex', '$text', '$geoDistance', '$geoShape'];
+/** Array containing all valid special query operator keys. */
 export const allSpecialQueryTypes = ['$textSpan'];
+/** Array containing all valid query operator keys. */
 export const allQueryTypes = [...allLogicalQueryTypes, ...allComparisonQueryTypes, ...allSpecialQueryTypes];
+/** Array containing all valid logical operators ('and', 'or'). */
 export const allOperators = ['and', 'or'];
+/** Array containing all valid text span query modes. */
 export const allTextSpanQueryModes = ['best', 'most', 'cross'];

package/orm/server/database-schema.js

@@ -1,13 +1,36 @@
 import { isDefined } from '../../utils/type-guards.js';
 import { getDrizzleTableFromType, getPgEnum, registerEnum } from './drizzle/schema-converter.js';
+/**
+ * Represents a database schema, providing methods to access tables and enums within that schema.
+ * @template SchemaName The name of the PostgreSQL schema.
+ */
 export class DatabaseSchema {
+    /** The name of the PostgreSQL schema. */
     name;
+    /**
+     * Creates an instance of DatabaseSchema.
+     * @param name The name of the PostgreSQL schema.
+     */
     constructor(name) {
         this.name = name;
     }
+    /**
+     * Gets the Drizzle table object corresponding to the given entity type within this schema.
+     * @template T The entity type.
+     * @param type The entity class.
+     * @returns The Drizzle table object.
+     */
     getTable(type) {
         return getDrizzleTableFromType(type, this.name);
     }
+    /**
+     * Gets the Drizzle enum object corresponding to the given enumeration within this schema.
+     * If a name is provided, it registers the enum with that name first.
+     * @template T The enumeration type.
+     * @param enumeration The enumeration object.
+     * @param name Optional name to register the enum with.
+     * @returns The Drizzle enum object.
+     */
     getEnum(enumeration, name) {
         if (isDefined(name)) {
             registerEnum(enumeration, name);
@@ -15,6 +38,12 @@ export class DatabaseSchema {
         return getPgEnum(this.name, enumeration); // eslint-disable-line @typescript-eslint/no-unsafe-return
     }
 }
+/**
+ * Factory function to create a DatabaseSchema instance.
+ * @template Name The name of the PostgreSQL schema.
+ * @param name The name of the PostgreSQL schema.
+ * @returns A new DatabaseSchema instance.
+ */
 export function databaseSchema(name) {
     return new DatabaseSchema(name);
 }