@tstdl/base 0.93.44 → 0.93.46

package/document-management/server/services/document-management-ai.service.js

@@ -97,6 +97,9 @@ let DocumentManagementAiService = DocumentManagementAiService_1 = class Document
         const env_1 = { stack: [], error: void 0, hasError: false };
         try {
             const document = await this.#documentRepository.loadByQuery({ tenantId, id: documentId });
+            if (isNotNull(document.typeId)) {
+                return document.typeId;
+            }
             const fileContentStream = this.#documentFileService.getContentStream(document);
             const tmpFile = __addDisposableResource(env_1, await TemporaryFile.from(fileContentStream), true);
             const filePart = await this.#aiService.processFile({ path: tmpFile.path, mimeType: document.mimeType });

package/orm/sqls.d.ts

@@ -4,9 +4,9 @@
  * simplifying common SQL operations like generating UUIDs, working with intervals,
  * and aggregating data.
  */
-import type { EnumerationObject, EnumerationValue } from '../types/types.js';
-import { type AnyColumn, type Column, type SQL, type SQLChunk } from 'drizzle-orm';
+import { Column, type AnyColumn, type SQL, type SQLChunk } from 'drizzle-orm';
 import type { GetSelectTableSelection, SelectResultField, TableLike } from 'drizzle-orm/query-builders/select.types';
+import type { EnumerationObject, EnumerationValue } from '../types/types.js';
 import { type PgEnumFromEnumeration } from './enums.js';
 import type { TsVectorWeight } from './query/index.js';
 import type { Uuid } from './types.js';
@@ -61,7 +61,38 @@ export type TsHeadlineOptions = {
     fragmentDelimiter?: string;
 };
 export declare function enumValue<T extends EnumerationObject>(enumeration: T, dbEnum: PgEnumFromEnumeration<T> | string | null, value: EnumerationValue<T>): SQL<string>;
-export declare function singleReferenceCheck<T extends EnumerationObject>(enumeration: T, dbEnum: PgEnumFromEnumeration<T> | string | null, discriminator: Column, columns: Column[], columnMapping: Record<EnumerationValue<T>, Column | null>): SQL;
+/**
+ *
+ * Generates a SQL condition that ensures exactly one of the specified columns is non-null and allows for custom conditions.
+ * @param enumeration The enumeration object
+ * @param discriminator The column used to discriminate between different enumeration values
+ * @param conditionMapping An object mapping enumeration values to columns and conditions
+ */
+export declare function exclusiveReference<T extends EnumerationObject>(enumeration: T, discriminator: Column, conditionMapping: Record<EnumerationValue<T>, Column | [Column, condition: boolean | SQL]>): SQL;
+export declare function exclusiveNotNull(...columns: Column[]): SQL;
+/**
+ * Generates a SQL `CASE ... WHEN ... END` statement for dynamic condition mapping based on an enumeration.
+ *
+ * This function is particularly useful for scenarios where you need to apply different logical
+ * conditions based on the value of a "type" or "status" column (the discriminator). The resulting
+ * `CASE` statement returns a boolean value (`TRUE` or `FALSE`).
+ *
+ * @param enumeration - The enumeration object
+ *
+ * @param discriminator - The column whose value is being evaluated in the `CASE` statement (e.g., the `status` column).
+ *
+ * @param conditionMapping - An object that maps
+ *   each enumeration key to the condition that should be applied when the discriminator matches that key's value.
+ *   The value can be:
+ *   - `boolean`: Directly results in `THEN TRUE` or `THEN FALSE`.
+ *   - `Column`: A reference to another column. The condition applied to it is determined by `defaultColumnCondition`.
+ *   - `SQL`: A raw SQL chunk for a custom, complex condition.
+ *
+ * @param defaultColumnCondition - An optional function
+ *   that defines the default condition to apply when a `Column` is provided in `conditionMapping`.
+ *   By default, it generates an `IS NOT NULL` check.
+ */
+export declare function enumerationCaseWhen<T extends EnumerationObject>(enumeration: T, discriminator: Column, conditionMapping: Record<EnumerationValue<T>, Column | boolean | SQL>, defaultColumnCondition?: (column: Column) => SQL<unknown>): 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,6 +1,13 @@
-import { objectEntries } from '../utils/object/object.js';
-import { assertDefined, isDefined, isNotNull, isNull, isNumber, isString } from '../utils/type-guards.js';
-import { and, eq, sql, Table } from 'drizzle-orm';
+/**
+ * @module
+ * Provides utility SQL functions and constants for use with Drizzle ORM,
+ * simplifying common SQL operations like generating UUIDs, working with intervals,
+ * and aggregating data.
+ */
+import { and, Column, eq, sql, isNotNull as sqlIsNotNull, Table } from 'drizzle-orm';
+import { match, P } from 'ts-pattern';
+import { mapObjectValues, objectEntries, objectValues } from '../utils/object/object.js';
+import { assertDefined, isDefined, isInstanceOf, isNull, isNumber, isString } from '../utils/type-guards.js';
 import { getEnumName } from './enums.js';
 /** Drizzle SQL helper for getting the current transaction's timestamp. Returns a Date object. */
 export const TRANSACTION_TIMESTAMP = sql `transaction_timestamp()`;
@@ -17,18 +24,62 @@ export function enumValue(enumeration, dbEnum, value) {
     const enumType = isString(dbEnum) ? sql `"${sql.raw(dbEnum)}"` : dbEnum;
     return sql `'${sql.raw(String(value))}'::${enumType}`;
 }
-export function singleReferenceCheck(enumeration, dbEnum, discriminator, columns, columnMapping) {
-    const whens = [];
-    for (const [value, column] of objectEntries(columnMapping)) {
-        if (isNotNull(column)) {
-            whens.push(sql `    WHEN ${enumValue(enumeration, dbEnum, value)} THEN ${column} IS NOT NULL`);
+/**
+ *
+ * Generates a SQL condition that ensures exactly one of the specified columns is non-null and allows for custom conditions.
+ * @param enumeration The enumeration object
+ * @param discriminator The column used to discriminate between different enumeration values
+ * @param conditionMapping An object mapping enumeration values to columns and conditions
+ */
+export function exclusiveReference(enumeration, discriminator, conditionMapping) {
+    const columns = objectValues(conditionMapping).map((value) => isInstanceOf(value, Column) ? value : value[0]);
+    const mapping = mapObjectValues(conditionMapping, (value) => {
+        if (isInstanceOf(value, Column)) {
+            return value;
         }
+        return value[1];
+    });
+    return and(exclusiveNotNull(...columns), enumerationCaseWhen(enumeration, discriminator, mapping));
+}
+export function exclusiveNotNull(...columns) {
+    return eq(numNonNulls(...columns), sql.raw('1'));
+}
+/**
+ * Generates a SQL `CASE ... WHEN ... END` statement for dynamic condition mapping based on an enumeration.
+ *
+ * This function is particularly useful for scenarios where you need to apply different logical
+ * conditions based on the value of a "type" or "status" column (the discriminator). The resulting
+ * `CASE` statement returns a boolean value (`TRUE` or `FALSE`).
+ *
+ * @param enumeration - The enumeration object
+ *
+ * @param discriminator - The column whose value is being evaluated in the `CASE` statement (e.g., the `status` column).
+ *
+ * @param conditionMapping - An object that maps
+ *   each enumeration key to the condition that should be applied when the discriminator matches that key's value.
+ *   The value can be:
+ *   - `boolean`: Directly results in `THEN TRUE` or `THEN FALSE`.
+ *   - `Column`: A reference to another column. The condition applied to it is determined by `defaultColumnCondition`.
+ *   - `SQL`: A raw SQL chunk for a custom, complex condition.
+ *
+ * @param defaultColumnCondition - An optional function
+ *   that defines the default condition to apply when a `Column` is provided in `conditionMapping`.
+ *   By default, it generates an `IS NOT NULL` check.
+ */
+export function enumerationCaseWhen(enumeration, discriminator, conditionMapping, defaultColumnCondition = (column) => sqlIsNotNull(column)) {
+    const whens = [];
+    for (const [key, value] of objectEntries(conditionMapping)) {
+        const condition = match(value)
+            .with(P.boolean, (bool) => bool ? sql `TRUE` : sql `FALSE`)
+            .when((value) => isInstanceOf(value, Column), (col) => defaultColumnCondition(col))
+            .otherwise((rawSql) => rawSql);
+        whens.push(sql `    WHEN ${enumValue(enumeration, null, key)} THEN ${condition}`);
     }
-    return and(sql `
+    return sql `
   CASE ${discriminator}
 ${sql.join(whens, sql `\n`)}
     ELSE FALSE
-  END`, eq(numNonNulls(...columns), sql.raw('1')));
+  END`;
 }
 export function array(values) {
     const valueString = sql.join(values, sql.raw(', '));

package/package.json

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

package/utils/type-guards.d.ts

@@ -1,4 +1,4 @@
-import type { AbstractConstructor, BinaryData, JsonPrimitive, PascalCase, Primitive, Type, TypedArray } from '../types/index.js';
+import type { AbstractConstructor, AbstractType, BinaryData, JsonPrimitive, PascalCase, Primitive, Type, TypedArray } from '../types/index.js';
 export type AssertionMessage = string | (() => string);
 export type IsFunction<T> = <U extends T = T>(value: any) => value is U;
 export type IsNotFunction<T> = <V>(value: V) => value is Exclude<V, T>;
@@ -269,9 +269,9 @@ export declare const assertReadableStream: <T = any>(value: any, message?: Asser
 export declare const assertNotReadableStream: AssertNotFunction<ReadableStream>;
 export declare const assertReadableStreamPass: <T = any>(value: any, message?: AssertionMessage) => ReadableStream<T>;
 export declare const assertNotReadableStreamPass: AssertNotPassFunction<ReadableStream>;
-export declare const isInstanceOf: <T>(value: any, type: Type<T>) => value is T;
-export declare const isNotInstanceOf: <V, T>(value: V, type: Type<T>) => value is Exclude<V, T>;
-export declare const assertInstanceOf: <T>(value: any, type: Type<T>, message?: AssertionMessage) => asserts value is T;
-export declare const assertNotInstanceOf: <V, T>(value: V, type: Type<T>, message?: AssertionMessage) => asserts value is Exclude<V, T>;
-export declare const assertInstanceOfPass: <T>(value: any, type: Type<T>, message?: AssertionMessage) => T;
+export declare const isInstanceOf: <T>(value: any, type: AbstractType<T>) => value is T;
+export declare const isNotInstanceOf: <V, T>(value: V, type: AbstractType<T>) => value is Exclude<V, T>;
+export declare const assertInstanceOf: <T>(value: any, type: AbstractType<T>, message?: AssertionMessage) => asserts value is T;
+export declare const assertNotInstanceOf: <V, T>(value: V, type: AbstractType<T>, message?: AssertionMessage) => asserts value is Exclude<V, T>;
+export declare const assertInstanceOfPass: <T>(value: any, type: AbstractType<T>, message?: AssertionMessage) => T;
 export declare const assertNotInstanceOfPass: <V, T>(value: V, type: Type<T>, message?: AssertionMessage) => Exclude<V, T>;