@tstdl/base 0.93.41 → 0.93.43

package/audit/schemas.d.ts

@@ -1,6 +1,22 @@
 import { AuditEvent } from './audit.model.js';
 export declare const auditSchema: import("../orm/server/index.js").DatabaseSchema<"audit">;
-export declare const auditOutcome: import("drizzle-orm/pg-core").PgEnum<["pending", "success", "cancelled", "failure", "denied"]>;
-export declare const auditSeverity: import("drizzle-orm/pg-core").PgEnum<["error", "warn", "info", "critical"]>;
-export declare const actorType: import("drizzle-orm/pg-core").PgEnum<["user", "anonymous", "system", "api-key"]>;
+export declare const auditOutcome: import("../orm/enums.js").PgEnumFromEnumeration<{
+    readonly Pending: "pending";
+    readonly Success: "success";
+    readonly Cancelled: "cancelled";
+    readonly Failure: "failure";
+    readonly Denied: "denied";
+}>;
+export declare const auditSeverity: import("../orm/enums.js").PgEnumFromEnumeration<{
+    readonly Info: "info";
+    readonly Warn: "warn";
+    readonly Error: "error";
+    readonly Critical: "critical";
+}>;
+export declare const actorType: import("../orm/enums.js").PgEnumFromEnumeration<{
+    readonly Anonymous: "anonymous";
+    readonly System: "system";
+    readonly ApiKey: "api-key";
+    readonly User: "user";
+}>;
 export declare const auditEvent: import("../orm/server/types.js").PgTableFromType<typeof AuditEvent, "audit">;

package/document-management/server/schemas.d.ts

@@ -1,14 +1,55 @@
 import { Document, DocumentAssignmentScope, DocumentAssignmentTask, DocumentCategory, DocumentCollection, DocumentCollectionAssignment, DocumentProperty, DocumentPropertyValue, DocumentRequest, DocumentRequestCollectionAssignment, DocumentRequestsTemplate, DocumentRequestTemplate, DocumentTag, DocumentTagAssignment, DocumentType, DocumentTypeProperty, DocumentTypeValidation, DocumentValidationDefinition, DocumentValidationExecution, DocumentValidationExecutionRelatedDocument, DocumentWorkflow } from '../models/index.js';
 export declare const documentManagementSchema: import("../../orm/server/index.js").DatabaseSchema<"document_management">;
-export declare const documentApproval: import("drizzle-orm/pg-core").PgEnum<["pending", "approved", "rejected"]>;
-export declare const documentAssignmentTarget: import("drizzle-orm/pg-core").PgEnum<["request", "collection"]>;
-export declare const documentPropertyDataType: import("drizzle-orm/pg-core").PgEnum<["boolean", "date", "text", "decimal", "integer"]>;
-export declare const documentRequestState: import("drizzle-orm/pg-core").PgEnum<["open", "closed", "fulfilled"]>;
-export declare const documentValidationExecutionState: import("drizzle-orm/pg-core").PgEnum<["pending", "error", "running", "completed"]>;
-export declare const documentValidationResultStatus: import("drizzle-orm/pg-core").PgEnum<["warning", "failed", "passed"]>;
-export declare const documentWorkflowFailReason: import("drizzle-orm/pg-core").PgEnum<["no-suitable-collection", "no-suitable-request"]>;
-export declare const documentWorkflowState: import("drizzle-orm/pg-core").PgEnum<["pending", "error", "running", "completed", "failed", "review"]>;
-export declare const documentWorkflowStep: import("drizzle-orm/pg-core").PgEnum<["classification", "extraction", "assignment", "validation"]>;
+export declare const documentApproval: import("../../orm/enums.js").PgEnumFromEnumeration<{
+    readonly Pending: "pending";
+    readonly Approved: "approved";
+    readonly Rejected: "rejected";
+}>;
+export declare const documentAssignmentTarget: import("../../orm/enums.js").PgEnumFromEnumeration<{
+    readonly Collection: "collection";
+    readonly Request: "request";
+}>;
+export declare const documentPropertyDataType: import("../../orm/enums.js").PgEnumFromEnumeration<{
+    readonly Text: "text";
+    readonly Integer: "integer";
+    readonly Decimal: "decimal";
+    readonly Boolean: "boolean";
+    readonly Date: "date";
+}>;
+export declare const documentRequestState: import("../../orm/enums.js").PgEnumFromEnumeration<{
+    readonly Open: "open";
+    readonly Fulfilled: "fulfilled";
+    readonly Closed: "closed";
+}>;
+export declare const documentValidationExecutionState: import("../../orm/enums.js").PgEnumFromEnumeration<{
+    readonly Pending: "pending";
+    readonly Running: "running";
+    readonly Completed: "completed";
+    readonly Error: "error";
+}>;
+export declare const documentValidationResultStatus: import("../../orm/enums.js").PgEnumFromEnumeration<{
+    readonly Passed: "passed";
+    readonly Failed: "failed";
+    readonly Warning: "warning";
+}>;
+export declare const documentWorkflowFailReason: import("../../orm/enums.js").PgEnumFromEnumeration<{
+    readonly NoSuitableCollection: "no-suitable-collection";
+    readonly NoSuitableRequest: "no-suitable-request";
+}>;
+export declare const documentWorkflowState: import("../../orm/enums.js").PgEnumFromEnumeration<{
+    readonly Pending: "pending";
+    readonly Running: "running";
+    readonly Review: "review";
+    readonly Completed: "completed";
+    readonly Error: "error";
+    readonly Failed: "failed";
+}>;
+export declare const documentWorkflowStep: import("../../orm/enums.js").PgEnumFromEnumeration<{
+    readonly Classification: "classification";
+    readonly Extraction: "extraction";
+    readonly Assignment: "assignment";
+    readonly Validation: "validation";
+}>;
 export declare const document: import("../../orm/server/types.js").PgTableFromType<typeof Document, "document_management">;
 export declare const documentAssignmentScope: import("../../orm/server/types.js").PgTableFromType<typeof DocumentAssignmentScope, "document_management">;
 export declare const documentAssignmentTask: import("../../orm/server/types.js").PgTableFromType<typeof DocumentAssignmentTask, "document_management">;

package/orm/enums.d.ts

@@ -1,3 +1,5 @@
-import type { Enumeration } from '../types/types.js';
+import type { PgEnum } from 'drizzle-orm/pg-core';
+import type { Enumeration, EnumerationValue, UnionToTuple } from '../types/types.js';
 export declare function registerEnum(enumeration: Enumeration, name: string): void;
 export declare function getEnumName(enumeration: Enumeration): string | undefined;
+export type PgEnumFromEnumeration<T extends Enumeration> = PgEnum<Extract<UnionToTuple<`${EnumerationValue<T>}`>, [string, ...string[]]>>;

package/orm/server/database-schema.d.ts

@@ -1,11 +1,6 @@
-/**
- * @module
- * Provides utilities for defining and accessing database schemas, tables, and enums
- * within a specific PostgreSQL schema.
- */
-import type { PgEnum } from 'drizzle-orm/pg-core';
-import type { Enumeration, EnumerationValue, UnionToTuple } from '../../types/index.js';
+import type { Enumeration } from '../../types/index.js';
 import type { EntityType } from '../entity.js';
+import { type PgEnumFromEnumeration } from '../enums.js';
 import type { PgTableFromType } from './types.js';
 /**
  * Represents a database schema, providing methods to access tables and enums within that schema.
@@ -34,7 +29,7 @@ export declare class DatabaseSchema<SchemaName extends string> {
      * @param name Optional name to register the enum with.
      * @returns The Drizzle enum object.
      */
-    getEnum<T extends Enumeration>(enumeration: T, name?: string): PgEnum<UnionToTuple<`${EnumerationValue<T>}`> extends [string, ...string[]] ? UnionToTuple<`${EnumerationValue<T>}`> : never>;
+    getEnum<T extends Enumeration>(enumeration: T, name?: string): PgEnumFromEnumeration<T>;
 }
 /**
  * Factory function to create a DatabaseSchema instance.

package/orm/sqls.d.ts

@@ -7,6 +7,7 @@
 import type { EnumerationObject, EnumerationValue } from '../types/types.js';
 import { type AnyColumn, type Column, type SQL, type SQLChunk } from 'drizzle-orm';
 import type { GetSelectTableSelection, SelectResultField, TableLike } from 'drizzle-orm/query-builders/select.types';
+import { type PgEnumFromEnumeration } from './enums.js';
 import type { TsVectorWeight } from './query/index.js';
 import type { Uuid } from './types.js';
 /** Drizzle SQL helper for getting the current transaction's timestamp. Returns a Date object. */
@@ -59,8 +60,8 @@ export type TsHeadlineOptions = {
      */
     fragmentDelimiter?: string;
 };
-export declare function enumValue<T extends EnumerationObject>(enumeration: T, value: EnumerationValue<T>): SQL<string>;
-export declare function singleReferenceCheck<E extends EnumerationObject>(enumeration: E, discriminator: Column, columns: Column[], columnMapping: Record<EnumerationValue<E>, Column>): SQL;
+export declare function enumValue<T extends EnumerationObject>(enumeration: T, dbEnum: PgEnumFromEnumeration<T>, value: EnumerationValue<T>): SQL<string>;
+export declare function singleReferenceCheck<T extends EnumerationObject>(enumeration: T, dbEnum: PgEnumFromEnumeration<T>, discriminator: Column, columns: Column[], columnMapping: Record<EnumerationValue<T>, Column | null>): SQL;
 export declare function array<T>(values: SQL<T>[]): SQL<T[]>;
 export declare function array<T = unknown>(values: SQLChunk[]): SQL<T[]>;
 export declare function autoAlias<T>(column: AnyColumn<{

package/orm/sqls.js

@@ -1,4 +1,5 @@
-import { assertDefined, isDefined, isNumber, isString } from '../utils/type-guards.js';
+import { objectEntries } from '../utils/object/object.js';
+import { assertDefined, isDefined, isNotNull, isNumber, isString } from '../utils/type-guards.js';
 import { and, eq, sql, Table } from 'drizzle-orm';
 import { getEnumName } from './enums.js';
 /** Drizzle SQL helper for getting the current transaction's timestamp. Returns a Date object. */
@@ -7,22 +8,23 @@ export const TRANSACTION_TIMESTAMP = sql `transaction_timestamp()`;
 export const RANDOM_UUID_V4 = sql `gen_random_uuid()`;
 /** Drizzle SQL helper for generating a random UUID (v7). Returns a Uuid string. */
 export const RANDOM_UUID_V7 = sql `uuidv7()`;
-export function enumValue(enumeration, value) {
+export function enumValue(enumeration, dbEnum, value) {
     const enumName = getEnumName(enumeration);
     assertDefined(enumName, 'Enumeration is not registered.');
-    return sql `'${sql.raw(String(value))}'::${sql.raw(enumName)}`;
+    return sql `'${sql.raw(String(value))}'::${dbEnum}`;
 }
-export function singleReferenceCheck(enumeration, discriminator, columns, columnMapping) {
+export function singleReferenceCheck(enumeration, dbEnum, discriminator, columns, columnMapping) {
     const whens = [];
-    for (const [value, column] of Object.entries(columnMapping)) {
-        whens.push(sql `  WHEN ${enumValue(enumeration, value)} THEN ${column} IS NOT NULL`);
+    for (const [value, column] of objectEntries(columnMapping)) {
+        if (isNotNull(column)) {
+            whens.push(sql `    WHEN ${enumValue(enumeration, dbEnum, value)} THEN ${column} IS NOT NULL`);
+        }
     }
     return and(sql `
-CASE ${discriminator}
+  CASE ${discriminator}
 ${sql.join(whens, sql `\n`)}
-  ELSE FALSE
-END
-`, eq(numNonNulls(...columns), sql.raw('1')));
+    ELSE FALSE
+  END`, eq(numNonNulls(...columns), sql.raw('1')));
 }
 export function array(values) {
     const valueString = sql.join(values, sql.raw(', '));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tstdl/base",
-  "version": "0.93.41",
+  "version": "0.93.43",
   "author": "Patrick Hein",
   "publishConfig": {
     "access": "public"