@tstdl/base 0.93.1 → 0.93.2

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

@@ -1,300 +0,0 @@
-import { toCamelCase, toSnakeCase } from 'drizzle-orm/casing';
-import { boolean, check, doublePrecision, foreignKey, index, integer, jsonb, pgSchema, primaryKey, text, unique, uniqueIndex, uuid } from 'drizzle-orm/pg-core';
-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';
-import { ArraySchema, BooleanSchema, DefaultSchema, EnumerationSchema, getObjectSchema, NullableSchema, NumberSchema, ObjectSchema, OptionalSchema, StringSchema, Uint8ArraySchema } from '../../../schema/index.js';
-import { compareByValueSelectionToOrder, orderRest } from '../../../utils/comparison.js';
-import { decodeText, encodeUtf8 } from '../../../utils/encoding.js';
-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, 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 { decryptBytes, encryptBytes } from '../encryption.js';
-import { convertQuery } from '../query-converter.js';
-const getDbSchema = memoizeSingle(pgSchema);
-export const getDrizzleTableFromType = memoize(_getDrizzleTableFromType);
-const columnDefinitionsSymbol = Symbol('columnDefinitions');
-const columnDefinitionsMapSymbol = Symbol('columnDefinitionsMap');
-export function getColumnDefinitions(table) {
-    return table[columnDefinitionsSymbol];
-}
-export function getColumnDefinitionsMap(table) {
-    return table[columnDefinitionsMapSymbol];
-}
-export function _getDrizzleTableFromType(type, fallbackSchemaName) {
-    const metadata = reflectionRegistry.getMetadata(type);
-    assertDefined(metadata, `Type ${type.name} does not have reflection metadata.`);
-    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 mergedTableReflectionData = tableReflectionDatas.reduceRight((merged, data) => ({ ...merged, ...data }), {});
-    const tableReflectionData = tableReflectionDatas[0];
-    const schema = assertDefinedPass(mergedTableReflectionData.schema ?? fallbackSchemaName, 'Table schema not provided');
-    const tableName = tableReflectionData?.name ?? getDefaultTableName(type);
-    const dbSchema = getDbSchema(schema);
-    const columnDefinitions = getPostgresColumnEntries(type, dbSchema, tableName);
-    const columnDefinitionsMap = new Map(columnDefinitions.map((column) => [column.objectPath.path, column]));
-    function getColumn(table, propertyName) {
-        return assertDefinedPass(table[propertyName], `Property "${propertyName}" does not exist on ${type.name}`);
-    }
-    function buildIndex(table, data, columnName) {
-        const columns = (data.columns ?? [columnName]).map((columnValue) => {
-            assertDefined(columnValue, 'Missing column name for index.');
-            const [columnName, columnOrder] = isString(columnValue) ? [columnValue] : columnValue;
-            const order = columnOrder ?? data.order ?? 'asc';
-            let column = getColumn(table, columnName);
-            column = column[order]();
-            if (data.options?.nulls == 'first') {
-                column = column.nullsFirst();
-            }
-            else if (data.options?.nulls == 'last') {
-                column = column.nullsLast();
-            }
-            return column;
-        });
-        const indexFn = (data.options?.unique == true) ? uniqueIndex : index;
-        let builder = indexFn(data.options?.name ?? getIndexName(tableName, columns, { naming: data.options?.naming })).using(data.options?.using ?? 'btree', ...columns);
-        if (isDefined(data.options?.where)) {
-            const query = convertQuery(data.options.where(table), table, columnDefinitionsMap);
-            builder = builder.where(query.inlineParams());
-        }
-        return builder;
-    }
-    function buildPrimaryKey(table) {
-        const columns = primaryKeyColumnDefinitions.map((columnDefinition) => getColumn(table, columnDefinition.name));
-        return primaryKey({
-            name: mergedTableReflectionData.compundPrimaryKeyName ?? getPrimaryKeyName(tableName, columns, { naming: mergedTableReflectionData.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) => [
-        ...((primaryKeyColumnDefinitions.length > 1)
-            ? [buildPrimaryKey(table)]
-            : []),
-        ...(columnDefinitions.map((columnDefinition) => {
-            const indexData = columnDefinition.reflectionData?.index;
-            if (isUndefined(indexData)) {
-                return undefined;
-            }
-            return buildIndex(table, indexData, columnDefinition.name);
-        }).filter(isDefined)),
-        ...tableReflectionDatas.flatMap((tableReflectionData) => {
-            return tableReflectionData.foreignKeys?.map((foreignKeyData) => {
-                const foreignTable = getDrizzleTableFromType(foreignKeyData.target(), dbSchema.schemaName);
-                return foreignKey({
-                    name: foreignKeyData.options?.name ?? getForeignKeyName(tableName, foreignKeyData.columns, { naming: foreignKeyData.options?.naming }),
-                    columns: foreignKeyData.columns.map((column) => getColumn(table, column)),
-                    foreignColumns: foreignKeyData.foreignColumns.map((column) => getColumn(foreignTable, column)),
-                });
-            }) ?? [];
-        }),
-        ...tableReflectionDatas.flatMap((tableReflectionData) => tableReflectionData.unique).filter(isDefined).map((data) => {
-            const columns = data.columns?.map((column) => getColumn(table, column));
-            let constraint = unique(data.options?.name ?? getUniqueName(tableName, columns, { naming: data.options?.naming })).on(...columns);
-            if (data.options?.nulls == 'not distinct') {
-                constraint = constraint.nullsNotDistinct();
-            }
-            return constraint;
-        }),
-        ...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;
-    drizzleSchema[columnDefinitionsMapSymbol] = columnDefinitionsMap;
-    return drizzleSchema;
-}
-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);
-    const entries = objectEntries(objectSchema.properties).toSorted(compareByValueSelectionToOrder(['id', orderRest, 'metadata'], (item) => item[0])).flatMap(([property, schema]) => {
-        const columnReflectionData = metadata.properties.get(property)?.data.tryGet('orm');
-        const columnName = columnReflectionData?.name ?? toSnakeCase(property);
-        if ((schema instanceof ObjectSchema) && !(schema instanceof JsonSchema)) {
-            const propertyMetadata = reflectionRegistry.getMetadata(type)?.properties.get(property);
-            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, dbSchema, tableName, path.add(property), nestedPrefix);
-        }
-        const objectPath = path.add(property);
-        const encrypted = columnReflectionData?.encrypted == true;
-        const toDatabase = encrypted
-            ? async (value, context) => {
-                const bytes = encodeUtf8(value);
-                return await encryptBytes(bytes, context.encryptionKey);
-            }
-            : (value) => value;
-        const fromDatabase = encrypted
-            ? async (value, context) => {
-                const decrypted = await decryptBytes(value, context.encryptionKey);
-                return decodeText(decrypted);
-            }
-            : (value) => value;
-        const prefixedColumnName = [prefix, columnName].join('');
-        return [{
-                name: toCamelCase(prefixedColumnName),
-                objectPath,
-                reflectionData: columnReflectionData,
-                buildType: (options) => getPostgresColumn(tableName, toSnakeCase(prefixedColumnName), dbSchema, schema, columnReflectionData ?? {}, options, { type, property }),
-                dereferenceObjectPath: compileDereferencer(objectPath, { optional: true }),
-                toDatabase,
-                fromDatabase,
-            }];
-    });
-    return entries;
-}
-function getPostgresColumn(tableName, columnName, dbSchema, propertySchema, reflectionData, options, context) {
-    let nullable = false;
-    let array = false;
-    let baseSchema = propertySchema;
-    while (true) {
-        if ((baseSchema instanceof NullableSchema) || (baseSchema instanceof OptionalSchema)) {
-            nullable = true;
-            baseSchema = baseSchema.schema;
-        }
-        else if (baseSchema instanceof ArraySchema) {
-            array = true;
-            baseSchema = baseSchema.itemSchema;
-        }
-        else {
-            break;
-        }
-    }
-    let column = getPostgresBaseColumn(columnName, dbSchema, baseSchema, reflectionData, context);
-    if (array) {
-        column = column.array();
-    }
-    if (!nullable) {
-        column = column.notNull();
-    }
-    if (isDefined(reflectionData.unique)) {
-        column = column.unique(reflectionData.unique.options?.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();
-    }
-    for (const { target, targetColumn } of reflectionData.references ?? []) {
-        column = column.references(() => {
-            const targetTable = getDrizzleTableFromType(target(), dbSchema.schemaName);
-            return targetTable[(targetColumn ?? 'id')];
-        });
-    }
-    if (isDefined(reflectionData.references)) {
-    }
-    return column;
-}
-function getPostgresBaseColumn(columnName, dbSchema, schema, reflectionData, context) {
-    if (schema instanceof DefaultSchema) {
-        const column = getPostgresBaseColumn(columnName, dbSchema, schema.schema, reflectionData, context);
-        return column.default(schema.defaultValue);
-    }
-    if (reflectionData.encrypted) {
-        return bytea(columnName);
-    }
-    if (schema instanceof UuidSchema) {
-        let column = uuid(columnName);
-        if (schema.defaultRandom) {
-            column = column.defaultRandom();
-        }
-        return column;
-    }
-    if (schema instanceof TimestampSchema) {
-        return timestamp(columnName);
-    }
-    if (schema instanceof NumericDateSchema) {
-        return numericDate(columnName);
-    }
-    if (schema instanceof NumberSchema) {
-        return schema.integer
-            ? integer(columnName)
-            : doublePrecision(columnName);
-    }
-    if (schema instanceof StringSchema) {
-        return text(columnName);
-    }
-    if (schema instanceof BooleanSchema) {
-        return boolean(columnName);
-    }
-    if (schema instanceof EnumerationSchema) {
-        const pgEnum = getPgEnum(dbSchema, schema.enumeration, context);
-        return pgEnum(columnName);
-    }
-    if (schema instanceof JsonSchema) {
-        return jsonb(columnName);
-    }
-    if (schema instanceof Uint8ArraySchema) {
-        return bytea(columnName);
-    }
-    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);
-    if (isUndefined(enumName)) {
-        const errorMessage = 'Enum is not registered. Please register it using `databaseSchema.getEnum(MyEnum)` before use.';
-        if (isDefined(context)) {
-            throw new Error(`${errorMessage} (type: ${context.type.name}, property: ${context.property})`);
-        }
-        throw new Error(errorMessage);
-    }
-    const values = (isArray(enumeration) ? enumeration : enumValues(enumeration))
-        .map((value) => value.toString());
-    const dbEnum = dbSchema.enum(toSnakeCase(enumName), values);
-    if (enums.has([dbSchema.schemaName, enumeration])) {
-        enums.set([dbSchema.schemaName, enumeration], dbEnum);
-    }
-    return dbEnum;
-}
-function getDefaultTableName(type) {
-    return toSnakeCase(isString(type.entityName) ? type.entityName : type.name.replace(/\d+$/u, ''));
-}
-function getPrimaryKeyName(tableName, columns, options) {
-    return getIdentifier(tableName, columns, 'pk', options);
-}
-function getIndexName(tableName, columns, options) {
-    return getIdentifier(tableName, columns, 'idx', options);
-}
-function getUniqueName(tableName, columns, options) {
-    return getIdentifier(tableName, columns, 'unique', options);
-}
-function getForeignKeyName(tableName, columns, options) {
-    return getIdentifier(tableName, columns, 'fkey', options);
-}
-function getIdentifier(tableName, columns, suffix, options) {
-    const identifier = `${getTablePrefix(tableName, options?.naming)}_${getColumnNames(columns).join('_')}_${suffix}`;
-    if (identifier.length > 63) {
-        if (options?.naming != 'abbreviated-table') {
-            return getIdentifier(tableName, columns, suffix, { naming: 'abbreviated-table' });
-        }
-        throw new Error(`Identifier "${identifier}" for table "${tableName}" is too long. Maximum length is 63 characters.`);
-    }
-    return identifier;
-}
-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);
-}