@tstdl/base 0.93.39 → 0.93.41

package/orm/enums.d.ts

@@ -0,0 +1,3 @@
+import type { Enumeration } from '../types/types.js';
+export declare function registerEnum(enumeration: Enumeration, name: string): void;
+export declare function getEnumName(enumeration: Enumeration): string | undefined;

package/orm/enums.js

@@ -0,0 +1,14 @@
+import { tryGetEnumName } from '../enumeration/index.js';
+import { toSnakeCase } from '../utils/string/casing.js';
+import { isUndefined } from '../utils/type-guards.js';
+const enumNames = new Map();
+export function registerEnum(enumeration, name) {
+    enumNames.set(enumeration, toSnakeCase(name));
+}
+export function getEnumName(enumeration) {
+    const baseName = enumNames.get(enumeration) ?? tryGetEnumName(enumeration);
+    if (isUndefined(baseName)) {
+        return undefined;
+    }
+    return toSnakeCase(baseName);
+}

package/orm/server/database-schema.js

@@ -1,5 +1,6 @@
 import { isDefined } from '../../utils/type-guards.js';
-import { getDrizzleTableFromType, getPgEnum, registerEnum } from './drizzle/schema-converter.js';
+import { registerEnum } from '../enums.js';
+import { getDrizzleTableFromType, getPgEnum } 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.

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

@@ -10,6 +10,5 @@ export declare const getDrizzleTableFromType: typeof _getDrizzleTableFromType;
 export declare function getColumnDefinitions(table: PgTableWithColumns<any>): ColumnDefinition[];
 export declare function getColumnDefinitionsMap(table: PgTableWithColumns<any>): ColumnDefinitionsMap;
 export declare function _getDrizzleTableFromType<T extends EntityType, S extends string>(type: T, fallbackSchemaName?: S): PgTableFromType<T, S>;
-export declare function registerEnum(enumeration: Enumeration, name: string): void;
 export declare function getPgEnum(schema: string | PgSchema, enumeration: Enumeration, context?: ConverterContext): PgEnum<[string, ...string[]]>;
 export {};

package/orm/server/drizzle/schema-converter.js

@@ -3,7 +3,6 @@ import { toCamelCase, toSnakeCase } from 'drizzle-orm/casing';
 import { boolean, check, doublePrecision, foreignKey, index, integer, jsonb, numeric, pgSchema, primaryKey, text, unique, uniqueIndex, uuid } from 'drizzle-orm/pg-core';
 import { match, P } from 'ts-pattern';
 import { MultiKeyMap } from '../../../data-structures/multi-key-map.js';
-import { tryGetEnumName } from '../../../enumeration/enumeration.js';
 import { NotSupportedError } from '../../../errors/not-supported.error.js';
 import { JsonPath } from '../../../json-path/json-path.js';
 import { reflectionRegistry } from '../../../reflection/registry.js';
@@ -17,6 +16,7 @@ import { fromEntries, mapObjectKeysToSnakeCase, objectEntries } from '../../../u
 import { assertDefined, assertDefinedPass, isArray, isDefined, isNotNull, isNotNullOrUndefined, isNull, isString, isUndefined } from '../../../utils/type-guards.js';
 import { resolveValueOrProvider } from '../../../utils/value-or-provider.js';
 import { bytea, numericDate, timestamp, tsvector } from '../../data-types/index.js';
+import { getEnumName } from '../../enums.js';
 import { JsonSchema, NumericDateSchema, NumericSchema, TimestampSchema, TsVectorSchema, UuidSchema } from '../../schemas/index.js';
 import { decryptBytes, encryptBytes } from '../encryption.js';
 import { convertQuery, resolveTargetColumn, resolveTargetColumns } from '../query-converter.js';
@@ -323,14 +323,10 @@ function getPostgresBaseColumn(columnName, dbSchema, schema, reflectionData, con
         throw new NotSupportedError(`Schema "${schema.constructor.name}" not supported on type "${context.type.name}" for property "${context.property}"`);
     });
 }
-const enumNames = new Map();
 const enums = new MultiKeyMap();
-export function registerEnum(enumeration, name) {
-    enumNames.set(enumeration, toSnakeCase(name));
-}
 export function getPgEnum(schema, enumeration, context) {
     const dbSchema = isString(schema) ? getDbSchema(schema) : schema;
-    const enumName = enumNames.get(enumeration) ?? tryGetEnumName(enumeration);
+    const enumName = getEnumName(enumeration);
     if (isUndefined(enumName)) {
         const errorMessage = 'Enum is not registered. Please register it using `databaseSchema.getEnum(MyEnum)` before use.';
         if (isDefined(context)) {
@@ -340,7 +336,7 @@ export function getPgEnum(schema, enumeration, context) {
     }
     const values = (isArray(enumeration) ? enumeration : enumValues(enumeration))
         .map((value) => value.toString());
-    const dbEnum = dbSchema.enum(toSnakeCase(enumName), values);
+    const dbEnum = dbSchema.enum(enumName, values);
     if (enums.has([dbSchema.schemaName, enumeration])) {
         enums.set([dbSchema.schemaName, enumeration], dbEnum);
     }

package/orm/sqls.d.ts

@@ -1,3 +1,10 @@
+/**
+ * @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 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 { TsVectorWeight } from './query/index.js';
@@ -52,6 +59,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 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,17 +1,29 @@
-/**
- * @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 { isDefined, isNumber, isString } from '../utils/type-guards.js';
-import { sql, Table } from 'drizzle-orm';
+import { assertDefined, isDefined, 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. */
 export const TRANSACTION_TIMESTAMP = sql `transaction_timestamp()`;
 /** Drizzle SQL helper for generating a random UUID (v4). Returns a Uuid string. */
 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) {
+    const enumName = getEnumName(enumeration);
+    assertDefined(enumName, 'Enumeration is not registered.');
+    return sql `'${sql.raw(String(value))}'::${sql.raw(enumName)}`;
+}
+export function singleReferenceCheck(enumeration, 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`);
+    }
+    return and(sql `
+CASE ${discriminator}
+${sql.join(whens, sql `\n`)}
+  ELSE FALSE
+END
+`, eq(numNonNulls(...columns), sql.raw('1')));
+}
 export function array(values) {
     const valueString = sql.join(values, sql.raw(', '));
     return sql `ARRAY[${valueString}]`;

package/package.json

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