@tstdl/base 0.92.86 → 0.92.87

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

@@ -12,12 +12,12 @@ import { enumValues } from '../../../utils/enum.js';
 import { memoize, memoizeSingle } from '../../../utils/function/memoize.js';
 import { compileDereferencer } from '../../../utils/object/dereference.js';
 import { fromEntries, objectEntries } from '../../../utils/object/object.js';
-import { assertDefined, assertDefinedPass, isArray, isDefined, isNull, isString, isUndefined } from '../../../utils/type-guards.js';
+import { assertDefined, assertDefinedPass, isArray, isDefined, isNotNullOrUndefined, isNull, isString, isUndefined } from '../../../utils/type-guards.js';
+import { bytea, numericDate, timestamp } from '../../data-types/index.js';
 import { JsonSchema } from '../../schemas/json.js';
 import { NumericDateSchema } from '../../schemas/numeric-date.js';
 import { TimestampSchema } from '../../schemas/timestamp.js';
 import { UuidSchema } from '../../schemas/uuid.js';
-import { bytea, numericDate, timestamp } from '../data-types/index.js';
 import { decryptBytes, encryptBytes } from '../encryption.js';
 const getDbSchema = memoizeSingle(pgSchema);
 export const getDrizzleTableFromType = memoize(_getDrizzleTableFromType);
@@ -28,11 +28,18 @@ export function getColumnDefinitions(table) {
 export function _getDrizzleTableFromType(type, schemaName) {
     const metadata = reflectionRegistry.getMetadata(type);
     assertDefined(metadata, `Type ${type.name} does not have reflection metadata.`);
-    const tableReflectionData = metadata.data.tryGet('orm');
+    const tableReflectionDatas = [];
+    for (let currentMetadata = metadata; isNotNullOrUndefined(currentMetadata?.parent); currentMetadata = reflectionRegistry.getMetadata(currentMetadata.parent)) {
+        const tableReflectionData = currentMetadata.data.tryGet('orm');
+        if (isDefined(tableReflectionData)) {
+            tableReflectionDatas.push(tableReflectionData);
+        }
+    }
+    const tableReflectionData = tableReflectionDatas[0];
     const schema = assertDefinedPass(schemaName ?? tableReflectionData?.schema, 'Table schema not provided');
     const tableName = tableReflectionData?.name ?? getDefaultTableName(type);
     const dbSchema = getDbSchema(schema);
-    const columnDefinitions = getPostgresColumnEntries(type, tableName, dbSchema);
+    const columnDefinitions = getPostgresColumnEntries(type, dbSchema, tableName);
     function getColumn(table, propertyName) {
         return assertDefinedPass(table[propertyName], `Property "${propertyName}" does not exist on ${type.name}`);
     }
@@ -52,14 +59,21 @@ export function _getDrizzleTableFromType(type, schemaName) {
             return column;
         });
         const indexFn = (data.options?.unique == true) ? uniqueIndex : index;
-        return indexFn(data.name).using(data.options?.using ?? 'btree', ...columns);
+        return indexFn(data.name ?? getIndexName(tableName, columns, { naming: data.options?.naming })).using(data.options?.using ?? 'btree', ...columns);
     }
-    const primaryKeyColumns = columnDefinitions.filter((columnDefinition) => columnDefinition.reflectionData?.primaryKey == true);
-    const skipPrimaryKey = primaryKeyColumns.length > 1;
+    function buildPrimaryKey(table) {
+        const columns = primaryKeyColumnDefinitions.map((columnDefinition) => getColumn(table, columnDefinition.name));
+        return primaryKey({
+            name: tableReflectionData?.compundPrimaryKeyName ?? getPrimaryKeyName(tableName, columns, { naming: tableReflectionData?.compundPrimaryKeyNaming }),
+            columns
+        });
+    }
+    const primaryKeyColumnDefinitions = columnDefinitions.filter((columnDefinition) => columnDefinition.reflectionData?.primaryKey == true);
+    const skipPrimaryKey = primaryKeyColumnDefinitions.length > 1;
     const columnEntries = columnDefinitions.map((entry) => [entry.name, entry.buildType({ skipPrimaryKey })]);
     const drizzleSchema = dbSchema.table(tableName, fromEntries(columnEntries), (table) => [
-        ...((primaryKeyColumns.length > 1)
-            ? [primaryKey({ columns: primaryKeyColumns.map((columnDefinition) => getColumn(table, columnDefinition.name)) })]
+        ...((primaryKeyColumnDefinitions.length > 1)
+            ? [buildPrimaryKey(table)]
             : []),
         ...(columnDefinitions.map((columnDefinition) => {
             const indexData = columnDefinition.reflectionData?.index;
@@ -68,21 +82,21 @@ export function _getDrizzleTableFromType(type, schemaName) {
             }
             return buildIndex(table, indexData, columnDefinition.name);
         }).filter(isDefined)),
-        ...(tableReflectionData?.unique?.map((data) => {
+        ...tableReflectionDatas.flatMap((tableReflectionData) => tableReflectionData.unique).filter(isDefined).map((data) => {
             const columns = data.columns?.map((column) => getColumn(table, column));
-            let constraint = unique(isDefined(data.name) ? toSnakeCase(data.name) : undefined).on(...columns);
+            let constraint = unique(data.name ?? getUniqueName(tableName, columns, { naming: data.options?.naming })).on(...columns);
             if (data.options?.nulls == 'not distinct') {
                 constraint = constraint.nullsNotDistinct();
             }
             return constraint;
-        }) ?? []),
-        ...(tableReflectionData?.index?.map((data) => buildIndex(table, data)) ?? []),
-        ...(tableReflectionData?.checks?.map((data) => check(data.name, data.builder(table))) ?? [])
+        }),
+        ...tableReflectionDatas.flatMap((tableReflectionData) => tableReflectionData.index).filter(isDefined).map((data) => buildIndex(table, data)),
+        ...tableReflectionDatas.flatMap((tableReflectionData) => tableReflectionData.checks).filter(isDefined).map((data) => check(data.name, data.builder(table)))
     ]);
     drizzleSchema[columnDefinitionsSymbol] = columnDefinitions;
     return drizzleSchema;
 }
-function getPostgresColumnEntries(type, tableName, dbSchema, path = new JsonPath({ dollar: false }), prefix = '') {
+function getPostgresColumnEntries(type, dbSchema, tableName, path = new JsonPath({ dollar: false }), prefix = '') {
     const metadata = reflectionRegistry.getMetadata(type);
     assertDefined(metadata, `Type ${type.name} does not have reflection metadata (path: ${path.toString()}).`);
     const objectSchema = getObjectSchema(type);
@@ -94,7 +108,7 @@ function getPostgresColumnEntries(type, tableName, dbSchema, path = new JsonPath
             assertDefined(propertyMetadata, `Property "${property}" of type "${type.name}" does not have reflection metadata (path: ${path.toString()}).`);
             const propertyPrefix = columnReflectionData?.embedded?.prefix;
             const nestedPrefix = [prefix, isNull(propertyPrefix) ? '' : propertyPrefix ?? `${columnName}_`].join('');
-            return getPostgresColumnEntries(columnReflectionData?.embedded?.type ?? propertyMetadata.type, tableName, dbSchema, path.add(property), nestedPrefix);
+            return getPostgresColumnEntries(columnReflectionData?.embedded?.type ?? propertyMetadata.type, dbSchema, tableName, path.add(property), nestedPrefix);
         }
         const objectPath = path.add(property);
         const encrypted = columnReflectionData?.encrypted == true;
@@ -115,7 +129,7 @@ function getPostgresColumnEntries(type, tableName, dbSchema, path = new JsonPath
                 name: toCamelCase(prefixedColumnName),
                 objectPath,
                 reflectionData: columnReflectionData,
-                buildType: (options) => getPostgresColumn(toSnakeCase(prefixedColumnName), dbSchema, schema, columnReflectionData ?? {}, options, { type, property }),
+                buildType: (options) => getPostgresColumn(tableName, toSnakeCase(prefixedColumnName), dbSchema, schema, columnReflectionData ?? {}, options, { type, property }),
                 dereferenceObjectPath: compileDereferencer(objectPath, { optional: true }),
                 toDatabase,
                 fromDatabase
@@ -123,7 +137,7 @@ function getPostgresColumnEntries(type, tableName, dbSchema, path = new JsonPath
     });
     return entries;
 }
-function getPostgresColumn(columnName, dbSchema, propertySchema, reflectionData, options, context) {
+function getPostgresColumn(tableName, columnName, dbSchema, propertySchema, reflectionData, options, context) {
     let nullable = false;
     let array = false;
     let baseSchema = propertySchema;
@@ -148,7 +162,7 @@ function getPostgresColumn(columnName, dbSchema, propertySchema, reflectionData,
         column = column.notNull();
     }
     if (isDefined(reflectionData.unique)) {
-        column = column.unique(reflectionData.unique.name, isString(reflectionData.unique.options?.nulls) ? { nulls: reflectionData.unique.options.nulls } : undefined);
+        column = column.unique(reflectionData.unique.name ?? getUniqueName(tableName, [columnName], { naming: reflectionData.unique.options?.naming }), isString(reflectionData.unique.options?.nulls) ? { nulls: reflectionData.unique.options.nulls } : undefined);
     }
     if ((reflectionData.primaryKey == true) && (options.skipPrimaryKey != true)) {
         column = column.primaryKey();
@@ -227,3 +241,18 @@ export function getPgEnum(schema, enumeration, context) {
 function getDefaultTableName(type) {
     return toSnakeCase(isString(type.entityName) ? type.entityName : type.name.replace(/\d+$/u, ''));
 }
+function getPrimaryKeyName(tableName, columns, options) {
+    return `${getTablePrefix(tableName, options?.naming)}_${getColumnNames(columns).join('_')}_pk`;
+}
+function getIndexName(tableName, columns, options) {
+    return `${getTablePrefix(tableName, options?.naming)}_${getColumnNames(columns).join('_')}_idx`;
+}
+function getUniqueName(tableName, columns, options) {
+    return `${getTablePrefix(tableName, options?.naming)}_${getColumnNames(columns).join('_')}_unique`;
+}
+function getTablePrefix(tableName, naming) {
+    return (naming == 'abbreviated-table') ? tableName.split('_').map((part) => part[0]).join('') : tableName;
+}
+function getColumnNames(columns) {
+    return columns.map((column) => isString(column) ? column : column.name);
+}

package/orm/server/repository.d.ts

@@ -8,7 +8,7 @@ import type { Query } from '../query.js';
 import type { EntityMetadataUpdate, EntityUpdate, LoadManyOptions, LoadOptions, NewEntity, Order } from '../repository.types.js';
 import { Database } from './database.js';
 import { type Transaction, type TransactionConfig } from './transaction.js';
-import type { PgTableFromType, TransformContext } from './types.js';
+import type { ColumnDefinition, PgTableFromType, TransformContext } from './types.js';
 type PgTransaction = DrizzlePgTransaction<PgQueryResultHKT, Record, Record>;
 export declare const repositoryType: unique symbol;
 export declare class EntityRepositoryConfig {
@@ -56,7 +56,7 @@ export declare class EntityRepository<T extends Entity | EntityWithoutMetadata =
     insert(entity: NewEntity<T>): Promise<T>;
     insertMany(entities: NewEntity<T>[]): Promise<T[]>;
     upsert(target: OneOrMany<Paths<UntaggedDeep<T>>>, entity: NewEntity<T>, update?: EntityUpdate<T>): Promise<T>;
-    upsertMany(target: OneOrMany<Paths<UntaggedDeep<T>>>, entities: NewEntity<T>[], update: EntityUpdate<T>): Promise<T[]>;
+    upsertMany(target: OneOrMany<Paths<UntaggedDeep<T>>>, entities: NewEntity<T>[], update?: EntityUpdate<T>): Promise<T[]>;
     update(id: string, update: EntityUpdate<T>): Promise<T>;
     tryUpdate(id: string, update: EntityUpdate<T>): Promise<T | undefined>;
     updateByQuery(query: Query<T>, update: EntityUpdate<T>): Promise<T>;
@@ -75,7 +75,7 @@ export declare class EntityRepository<T extends Entity | EntityWithoutMetadata =
     tryHardDeleteByQuery(query: Query<T>): Promise<T | undefined>;
     hardDeleteMany(ids: string[]): Promise<T[]>;
     hardDeleteManyByQuery(query: Query<T>): Promise<T[]>;
-    $getColumn(path: Paths<UntaggedDeep<T>>): PgColumn;
+    $getColumn(pathOrColumn: Paths<UntaggedDeep<T>> | ColumnDefinition): PgColumn;
     $convertOrderBy(orderBy: Order<T>): SQL<unknown>[];
     $convertQuery(query: Query<T>): SQL;
     $mapManyToEntity(columns: this['_inferSelect'][]): Promise<T[]>;
@@ -132,7 +132,8 @@ export declare class EntityRepository<T extends Entity | EntityWithoutMetadata =
     protected mapManyToInsertColumns(objects: (DeepPartial<T> | NewEntity<T>)[], transformContext: TransformContext): Promise<PgInsertValue<PgTableFromType>[]>;
     protected mapToInsertColumns(obj: DeepPartial<T> | NewEntity<T>, transformContext: TransformContext): Promise<PgInsertValue<PgTableFromType>>;
     protected mapUpdate(update: EntityUpdate<T>, transformContext: TransformContext): Promise<PgUpdateSetSource<PgTableFromType>>;
-    protected getIdLimitQuery(query: Query<T>): Omit<import("drizzle-orm/pg-core").PgSelectBase<string, {
+    protected getMetadataUpdate(update?: EntityUpdate<T>): PgUpdateSetSource<PgTableFromType<EntityType<Entity>>> | undefined;
+    protected getIdLimitSelect(query: Query<T>): Omit<import("drizzle-orm/pg-core").PgSelectBase<string, {
         id: PgColumn<{
             name: string;
             tableName: string;

package/orm/server/repository.js

@@ -22,8 +22,8 @@ import { mapAsync } from '../../utils/async-iterable-helpers/map.js';
 import { toArrayAsync } from '../../utils/async-iterable-helpers/to-array.js';
 import { importSymmetricKey } from '../../utils/cryptography.js';
 import { typeExtends } from '../../utils/index.js';
-import { fromDeepObjectEntries, objectEntries } from '../../utils/object/object.js';
-import { assertDefinedPass, isArray, isDefined, isUndefined } from '../../utils/type-guards.js';
+import { fromDeepObjectEntries, fromEntries, objectEntries } from '../../utils/object/object.js';
+import { assertDefinedPass, isArray, isDefined, isString, isUndefined } from '../../utils/type-guards.js';
 import { Entity } from '../entity.js';
 import { Database } from './database.js';
 import { getColumnDefinitions, getDrizzleTableFromType } from './drizzle/schema-converter.js';
@@ -249,8 +249,13 @@ let EntityRepository = class EntityRepository {
     async upsertMany(target, entities, update) {
         const transformContext = await this.getTransformContext();
         const targetColumns = toArray(target).map((path) => this.$getColumn(path));
-        const columns = await this.mapManyToColumns(entities, transformContext);
-        const mappedUpdate = await this.mapUpdate(update, transformContext);
+        const columns = await this.mapManyToInsertColumns(entities, transformContext);
+        const mappedUpdate = isDefined(update)
+            ? await this.mapUpdate(update, transformContext)
+            : {
+                ...fromEntries(this.#columnDefinitions.map((column) => [column.name, sql `excluded.${sql.identifier(this.$getColumn(column).name)}`])),
+                ...this.getMetadataUpdate(update)
+            };
         const rows = await this.session
             .insert(this.#table)
             .values(columns)
@@ -291,11 +296,11 @@ let EntityRepository = class EntityRepository {
     async tryUpdateByQuery(query, update) {
         const transformContext = await this.getTransformContext();
         const mappedUpdate = await this.mapUpdate(update, transformContext);
-        const idQuery = this.getIdLimitQuery(query);
+        const idQuery = this.getIdLimitSelect(query);
         const [row] = await this.session
             .update(this.#table)
             .set(mappedUpdate)
-            .where(inArray(this.#table.id, idQuery))
+            .where(inArray(this.#table.id, idQuery.for('update')))
             .returning();
         if (isUndefined(row)) {
             return undefined;
@@ -352,14 +357,14 @@ let EntityRepository = class EntityRepository {
         if (!this.hasMetadata) {
             return this.tryHardDeleteByQuery(query);
         }
-        const idQuery = this.getIdLimitQuery(query);
+        const idQuery = this.getIdLimitSelect(query);
         const [row] = await this.session
             .update(this.#tableWithMetadata)
             .set({
             deleteTimestamp: TRANSACTION_TIMESTAMP,
             attributes: this.getAttributesUpdate(metadataUpdate?.attributes)
         })
-            .where(inArray(this.#table.id, idQuery))
+            .where(inArray(this.#table.id, idQuery.for('update')))
             .returning();
         if (isUndefined(row)) {
             return undefined;
@@ -412,10 +417,10 @@ let EntityRepository = class EntityRepository {
         return result;
     }
     async tryHardDeleteByQuery(query) {
-        const idQuery = this.getIdLimitQuery(query);
+        const idQuery = this.getIdLimitSelect(query);
         const [row] = await this.session
             .delete(this.#table)
-            .where(inArray(this.#table.id, idQuery))
+            .where(inArray(this.#table.id, idQuery.for('update')))
             .returning();
         if (isUndefined(row)) {
             return undefined;
@@ -435,9 +440,12 @@ let EntityRepository = class EntityRepository {
         const transformContext = await this.getTransformContext();
         return this.mapManyToEntity(rows, transformContext);
     }
-    $getColumn(path) {
-        const columnName = assertDefinedPass(this.#columnDefinitionsMap.get(path), `Could not map ${path} to column.`).name;
-        return this.#table[columnName];
+    $getColumn(pathOrColumn) {
+        if (isString(pathOrColumn)) {
+            const columnName = assertDefinedPass(this.#columnDefinitionsMap.get(pathOrColumn), `Could not map ${pathOrColumn} to column.`).name;
+            return this.#table[columnName];
+        }
+        return this.#table[pathOrColumn.name];
     }
     $convertOrderBy(orderBy) {
         if (isArray(orderBy)) {
@@ -487,7 +495,7 @@ let EntityRepository = class EntityRepository {
         return this.mapUpdate(update, transformContext);
     }
     $getIdLimitQuery(query) {
-        return this.getIdLimitQuery(query);
+        return this.getIdLimitSelect(query);
     }
     $getAttributesUpdate(attributes) {
         return this.getAttributesUpdate(attributes);
@@ -543,16 +551,19 @@ let EntityRepository = class EntityRepository {
         }
         return {
             ...mappedUpdate,
-            ...(this.hasMetadata
-                ? {
-                    attributes: this.getAttributesUpdate(update?.metadata?.attributes),
-                    revision: sql `${this.#tableWithMetadata.revision} + 1`,
-                    revisionTimestamp: TRANSACTION_TIMESTAMP
-                }
-                : undefined)
+            ...this.getMetadataUpdate(update)
         };
     }
-    getIdLimitQuery(query) {
+    getMetadataUpdate(update) {
+        return this.hasMetadata
+            ? {
+                attributes: this.getAttributesUpdate(update?.metadata?.attributes),
+                revision: sql `${this.#tableWithMetadata.revision} + 1`,
+                revisionTimestamp: TRANSACTION_TIMESTAMP
+            }
+            : undefined;
+    }
+    getIdLimitSelect(query) {
         const sqlQuery = this.$convertQuery(query);
         return this.session.select({ id: this.#table.id })
             .from(this.#table)

package/orm/server/sqls.d.ts

@@ -1,7 +1,15 @@
-import { type SQL } from 'drizzle-orm';
+import { type Column, type SQL } from 'drizzle-orm';
+import type { GetSelectTableSelection, SelectResultField, TableLike } from 'drizzle-orm/query-builders/select.types';
 import type { Uuid } from '../types.js';
 export declare const TRANSACTION_TIMESTAMP: SQL<Date>;
 export declare const RANDOM_UUID: SQL<Uuid>;
 type IntervalUnit = 'millennium' | 'millenniums' | 'millennia' | 'century' | 'centuries' | 'decade' | 'decades' | 'year' | 'years' | 'day' | 'days' | 'hour' | 'hours' | 'minute' | 'minutes' | 'second' | 'seconds' | 'millisecond' | 'milliseconds' | 'microsecond' | 'microseconds';
 export declare function interval(value: number, unit: IntervalUnit): SQL;
+export declare function arrayAgg<T extends Column>(column: T): SQL<SelectResultField<T>[]>;
+export declare function jsonAgg<T extends TableLike>(tableOrColumn: T): SQL<SelectResultField<GetSelectTableSelection<T>>[]>;
+export declare namespace jsonAgg {
+    var withNull: <T extends TableLike>(tableOrColumn: T) => SQL<(SelectResultField<GetSelectTableSelection<T>> | null)[]>;
+}
+export declare function coalesce<T extends (Column | SQL)[]>(...columns: T): SQL<SelectResultField<T>[number]>;
+export declare function toJsonb<T extends (Column | SQL)>(column: T): SQL<SelectResultField<T>>;
 export {};

package/orm/server/sqls.js

@@ -4,3 +4,16 @@ export const RANDOM_UUID = sql `gen_random_uuid()`;
 export function interval(value, unit) {
     return sql `(${value} ||' ${sql.raw(unit)}')::interval`;
 }
+export function arrayAgg(column) {
+    return sql `array_agg(${column})`;
+}
+export function jsonAgg(tableOrColumn) {
+    return sql `json_agg(${tableOrColumn})`;
+}
+jsonAgg.withNull = jsonAgg;
+export function coalesce(...columns) {
+    return sql `coalesce(${sql.join(columns, sql.raw(', '))})`;
+}
+export function toJsonb(column) {
+    return sql `to_jsonb(${column})`;
+}

package/orm/types.d.ts

@@ -1,11 +1,11 @@
 import type { $Type, HasDefault as DrizzleHasDefault, IsPrimaryKey as DrizzleIsPrimaryKey } from 'drizzle-orm';
-import type { boolean, date, doublePrecision, integer, jsonb, PgColumnBuilder, PgColumnBuilderBase, PgEnumColumnBuilderInitial, text, timestamp, uuid } from 'drizzle-orm/pg-core';
+import type { boolean, doublePrecision, integer, jsonb, PgColumnBuilder, PgColumnBuilderBase, PgEnumColumnBuilderInitial, text, uuid } from 'drizzle-orm/pg-core';
 import { Array, Integer } from '../schema/index.js';
 import type { AbstractConstructor, EnumerationObject, EnumerationValue, ObjectLiteral, UnionToTuple } from '../types.js';
 import type { GetTagMetadata, HasTag, Tagged, UnwrapTagged } from '../types/index.js';
+import type { bytea, numericDate, timestamp } from './data-types/index.js';
 import { Check, Column, Embedded, Encrypted, Index, PrimaryKey, References, Unique } from './decorators.js';
 import { Json, NumericDate, Timestamp, Uuid } from './schemas/index.js';
-import type { bytea } from './server/data-types/index.js';
 export type ColumnTypeTag = 'column';
 export type EmbeddedConfigTag = 'embedded';
 export type IsPrimaryKey<T> = T extends Tagged<unknown, ColumnTypeTag, PgColumnBuilderBase> ? Tagged<UnwrapTagged<T>, ColumnTypeTag, DrizzleIsPrimaryKey<GetTagMetadata<T, ColumnTypeTag>>> : Tagged<T, ColumnTypeTag, DrizzleIsPrimaryKey<ColumnBuilder<T>>>;
@@ -23,7 +23,7 @@ export type Uuid = Tagged<string, ColumnTypeTag, ReturnType<typeof uuid>>;
 export type Integer = Tagged<number, ColumnTypeTag, ReturnType<typeof integer>>;
 export type DoublePrecision = Tagged<number, ColumnTypeTag, ReturnType<typeof doublePrecision>>;
 export type Boolean = Tagged<number, ColumnTypeTag, ReturnType<typeof boolean>>;
-export type NumericDate = Tagged<number, ColumnTypeTag, ReturnType<typeof date>>;
+export type NumericDate = Tagged<number, ColumnTypeTag, ReturnType<typeof numericDate>>;
 export type Timestamp = Tagged<number, ColumnTypeTag, ReturnType<typeof timestamp>>;
 export type Bytea = Tagged<Uint8Array, ColumnTypeTag, ReturnType<typeof bytea>>;
 export type Encrypted<T> = Tagged<T, ColumnTypeTag, ReturnType<typeof bytea>>;

package/orm/utils.d.ts

@@ -0,0 +1,3 @@
+import type { Entity } from './entity.js';
+export declare function getEntityMap<T extends Entity>(entities: T[]): Map<string, T>;
+export declare function getEntityIds<T extends Entity>(entities: T[]): string[];

package/orm/utils.js

@@ -0,0 +1,6 @@
+export function getEntityMap(entities) {
+    return new Map(entities.map((entity) => [entity.id, entity]));
+}
+export function getEntityIds(entities) {
+    return entities.map((entity) => entity.id);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tstdl/base",
-  "version": "0.92.86",
+  "version": "0.92.87",
   "author": "Patrick Hein",
   "publishConfig": {
     "access": "public"
@@ -129,16 +129,18 @@
     "./utils/string": "./utils/string/index.js"
   },
   "dependencies": {
-    "@google-cloud/storage": "7.15",
-    "@google-cloud/vertexai": "1.9",
-    "disposablestack": "1.1",
+    "@google-cloud/storage": "^7.15",
+    "@google-cloud/vertexai": "^1.9",
+    "disposablestack": "^1.1",
     "luxon": "^3.5",
     "reflect-metadata": "^0.2",
     "rxjs": "^7.8",
-    "type-fest": "4.35"
+    "ts-pattern": "^5.6",
+    "type-fest": "^4.37"
   },
   "devDependencies": {
-    "@stylistic/eslint-plugin": "4.1",
+    "@biomejs/biome": "1.9",
+    "@stylistic/eslint-plugin": "4.2",
     "@types/chroma-js": "2.4",
     "@types/koa__router": "12.0",
     "@types/luxon": "3.4",
@@ -147,17 +149,17 @@
     "@types/node": "22",
     "@types/nodemailer": "6.4",
     "@types/pg": "8.11",
-    "@typescript-eslint/eslint-plugin": "8.25",
+    "@typescript-eslint/eslint-plugin": "8.26",
     "concurrently": "9.1",
     "drizzle-kit": "0.30",
     "eslint": "9.21",
     "globals": "16.0",
     "tsc-alias": "1.8",
-    "typescript": "5.7"
+    "typescript": "5.8"
   },
   "peerDependencies": {
     "@elastic/elasticsearch": "^8.17",
-    "@google/generative-ai": "^0.22",
+    "@google/generative-ai": "^0.23",
     "@tstdl/angular": "^0.92",
     "@zxcvbn-ts/core": "^3.0",
     "@zxcvbn-ts/language-common": "^3.0",
@@ -168,13 +170,13 @@
     "handlebars": "^4.7",
     "minio": "^8.0",
     "mjml": "^4.15",
-    "mongodb": "^6.13",
+    "mongodb": "^6.14",
     "nodemailer": "^6.10",
     "pg": "^8.13",
     "playwright": "^1.50",
     "preact": "^10.26",
     "preact-render-to-string": "^6.5",
-    "undici": "^7.3",
+    "undici": "^7.4",
     "urlpattern-polyfill": "^10.0"
   },
   "peerDependenciesMeta": {

package/pdf/pdf.service.d.ts

@@ -92,7 +92,6 @@ export declare class PdfService implements Resolvable<PdfServiceArgument> {
      * @returns pdf bytes
      */
     renderTemplate(keyOrTemplate: string | PdfTemplate, templateContext?: object, options?: PdfServiceRenderOptions): Promise<Uint8Array>;
-    merge(pdfs: (string | Uint8Array)[]): Promise<Uint8Array>;
     private renderStream;
 }
 export declare function pdfTemplate(name: string, fields: {

package/pdf/pdf.service.js

@@ -12,62 +12,6 @@ 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);
 };
-var __addDisposableResource = (this && this.__addDisposableResource) || function (env, value, async) {
-    if (value !== null && value !== void 0) {
-        if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
-        var dispose, inner;
-        if (async) {
-            if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
-            dispose = value[Symbol.asyncDispose];
-        }
-        if (dispose === void 0) {
-            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
-            dispose = value[Symbol.dispose];
-            if (async) inner = dispose;
-        }
-        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
-        if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };
-        env.stack.push({ value: value, dispose: dispose, async: async });
-    }
-    else if (async) {
-        env.stack.push({ async: true });
-    }
-    return value;
-};
-var __disposeResources = (this && this.__disposeResources) || (function (SuppressedError) {
-    return function (env) {
-        function fail(e) {
-            env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
-            env.hasError = true;
-        }
-        var r, s = 0;
-        function next() {
-            while (r = env.stack.pop()) {
-                try {
-                    if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
-                    if (r.dispose) {
-                        var result = r.dispose.call(r.value);
-                        if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
-                    }
-                    else s |= 1;
-                }
-                catch (e) {
-                    fail(e);
-                }
-            }
-            if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
-            if (env.hasError) throw env.error;
-        }
-        return next();
-    };
-})(typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
-    var e = new Error(message);
-    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
-});
-import { execFile as execFileCallback } from 'node:child_process';
-import { access, readFile, unlink, writeFile } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
-import { promisify } from 'node:util';
 import { BrowserContextController } from '../browser/browser-context-controller.js';
 import { BrowserController } from '../browser/browser-controller.js';
 import { PdfRenderOptions } from '../browser/pdf-options.js';
@@ -80,8 +24,7 @@ import { finalizeStream } from '../utils/stream/finalize-stream.js';
 import { readableStreamFromPromise } from '../utils/stream/readable-stream-from-promise.js';
 import { readBinaryStream } from '../utils/stream/stream-reader.js';
 import { timeout } from '../utils/timing.js';
-import { isDefined, isString } from '../utils/type-guards.js';
-const execFile = promisify(execFileCallback);
+import { isDefined } from '../utils/type-guards.js';
 export class PdfServiceRenderOptions extends PdfRenderOptions {
     browserContext;
     locale;
@@ -196,43 +139,6 @@ let PdfService = class PdfService {
         const stream = this.renderTemplateStream(keyOrTemplate, templateContext, options);
         return readBinaryStream(stream);
     }
-    async merge(pdfs) {
-        const env_1 = { stack: [], error: void 0, hasError: false };
-        try {
-            const stack = __addDisposableResource(env_1, new AsyncDisposableStack(), true);
-            const tmp = tmpdir();
-            const sourceFiles = await Promise.all(pdfs.map(async (pdf) => {
-                if (isString(pdf)) {
-                    return pdf;
-                }
-                const file = `${tmp}/${crypto.randomUUID()}.pdf`;
-                await writeFile(file, pdf);
-                stack.defer(async () => unlink(file));
-                return file;
-            }));
-            const resultFile = `${tmp}/${crypto.randomUUID()}.pdf`;
-            const resultPromise = execFile('pdfunite', [...sourceFiles, resultFile]);
-            const result = await resultPromise;
-            try {
-                await access(resultFile);
-                stack.defer(async () => unlink(resultFile));
-            }
-            catch { /* ignore */ }
-            if (resultPromise.child.exitCode != 0) {
-                throw new Error(result.stderr);
-            }
-            return readFile(resultFile);
-        }
-        catch (e_1) {
-            env_1.error = e_1;
-            env_1.hasError = true;
-        }
-        finally {
-            const result_1 = __disposeResources(env_1);
-            if (result_1)
-                await result_1;
-        }
-    }
     renderStream(handler, options = {}) {
         return readableStreamFromPromise(async () => {
             const context = options.browserContext ?? await this.browserController.newContext({ locale: options.locale ?? this.defaultLocale });

package/pdf/utils.d.ts

@@ -1 +1,3 @@
-export declare function getPdfPageCount(file: string): Promise<number>;
+export declare function getPdfPageCount(file: string | Uint8Array | ReadableStream<Uint8Array>): Promise<number>;
+export declare function mergePdfs(pdfs: (string | Uint8Array | ReadableStream<Uint8Array>)[]): Promise<Uint8Array>;
+export declare function mergePdfsStream(pdfs: (string | Uint8Array | ReadableStream<Uint8Array>)[]): Promise<ReadableStream<Uint8Array>>;