@flusys/nestjs-entity-builder 9.1.0 → 9.1.1

package/fesm/{362.js → 897.js}

@@ -2,9 +2,49 @@ import * as __rspack_external__flusys_nestjs_shared_dtos_c4585026 from "@flusys/
 import * as __rspack_external__nestjs_swagger_7cd450b5 from "@nestjs/swagger";
 import * as __rspack_external_class_transformer_c5a479fb from "class-transformer";
 import * as __rspack_external_class_validator_7b99ef4d from "class-validator";
-export const __rspack_esm_id = 362;
-export const __rspack_esm_ids = [362];
+import * as __rspack_external_node_crypto_2e7c4b46 from "node:crypto";
+import * as __rspack_external_typeorm from "typeorm";
+export const __rspack_esm_id = 897;
+export const __rspack_esm_ids = [897];
 export const __webpack_modules__ = {
+6576(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+const ENTITY_BUILDER_MODULE_OPTIONS = 'ENTITY_BUILDER_MODULE_OPTIONS';
+/**
+ * Largest bundle file plan-import / apply-import accept. The bundle is uploaded as a file, so the app's
+ * JSON body limit (Express's 100kb default) never applies to it and the app needs no setup for it.
+ */ const ENTITY_BUNDLE_MAX_BYTES = 20 * 1024 * 1024;
+/** A name `${var:NAME}` can carry; any other name could never be resolved on import. */ const BUNDLE_VARIABLE_NAME_PATTERN = /^[A-Za-z_][A-Za-z0-9_]*$/;
+/**
+ * Identifier whitelist enforced on every EntityDefinition/FieldDefinition `code`.
+ * Also the exact contract SchemaSyncService's DDL engine validates against
+ * before generating a table/column name.
+ */ const ENTITY_CODE_PATTERN = /^[a-z][a-z0-9_]{2,59}$/;
+/** Matches the `code` column length on both EntityDefinition and FieldDefinition. */ const ENTITY_CODE_MAX_LENGTH = 63;
+/** Defense-in-depth prefix applied to every dynamically created table name. */ const ENTITY_TABLE_PREFIX = 'eb_';
+/** The generic API controller's record endpoints - each can be created as a ready-made flow with the entity. */ const ENTITY_FLOW_ENDPOINTS = [
+    'insert',
+    'insertMany',
+    'getById',
+    'getByIds',
+    'getAll',
+    'getByFilter',
+    'update',
+    'updateMany',
+    'bulkUpsert',
+    'delete'
+];
+
+__webpack_require__.d(__webpack_exports__, {
+}, {
+  CP: ENTITY_BUILDER_MODULE_OPTIONS,
+  EA: ENTITY_BUNDLE_MAX_BYTES,
+  JI: BUNDLE_VARIABLE_NAME_PATTERN,
+  WT: ENTITY_FLOW_ENDPOINTS,
+  vs: ENTITY_CODE_PATTERN
+});
+
+
+},
 680(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
 /* import */ var _flusys_nestjs_shared_dtos__rspack_import_0 = __webpack_require__(6873);
 /* import */ var _nestjs_swagger__rspack_import_1 = __webpack_require__(6176);
@@ -1045,6 +1085,518 @@ __webpack_require__.d(__webpack_exports__, {
 });
 
 
+},
+1313(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+/**
+ * Lifecycle status of an EntityDefinition.
+ * DRAFT - metadata created, table not yet materialized.
+ * ACTIVE - table exists; flows read and write its records.
+ * DEPRECATED - no new writes; physical table/data left intact.
+ */ var EntityStatus = /*#__PURE__*/ function(EntityStatus) {
+    EntityStatus["DRAFT"] = "DRAFT";
+    EntityStatus["ACTIVE"] = "ACTIVE";
+    EntityStatus["DEPRECATED"] = "DEPRECATED";
+    return EntityStatus;
+}({});
+
+__webpack_require__.d(__webpack_exports__, {
+  c: () => (EntityStatus)
+});
+
+
+},
+9614(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+/**
+ * Storable field types a FieldDefinition can declare.
+ * Mapped to a driver-specific column type by SchemaDialectAdapterService.
+ */ var FieldType = /*#__PURE__*/ function(FieldType) {
+    FieldType["TEXT"] = "TEXT";
+    FieldType["LONG_TEXT"] = "LONG_TEXT";
+    FieldType["INTEGER"] = "INTEGER";
+    FieldType["DECIMAL"] = "DECIMAL";
+    FieldType["BOOLEAN"] = "BOOLEAN";
+    FieldType["DATE"] = "DATE";
+    FieldType["DATETIME"] = "DATETIME";
+    FieldType["EMAIL"] = "EMAIL";
+    FieldType["SINGLE_SELECT"] = "SINGLE_SELECT";
+    FieldType["MULTI_SELECT"] = "MULTI_SELECT";
+    FieldType["RELATION"] = "RELATION";
+    FieldType["JSON"] = "JSON";
+    FieldType["FILE"] = "FILE";
+    return FieldType;
+}({});
+
+__webpack_require__.d(__webpack_exports__, {
+  P: () => (FieldType)
+});
+
+
+},
+6256(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+const FLOW_NODE_TYPES = [
+    'trigger',
+    'validate',
+    'permission_check',
+    'company_branch_check',
+    'set',
+    'condition',
+    'switch',
+    'foreach',
+    'entity_insert',
+    'entity_update',
+    'entity_delete',
+    'entity_get',
+    'entity_query',
+    'commit',
+    'call_flow',
+    'http_request',
+    'publish_event',
+    'send_notification',
+    'send_email',
+    'respond',
+    'code'
+];
+/** A failure of these always ends the run: checks can never be carried past, and Save progress cannot run in a savepoint. */ const NON_CONTINUABLE_NODE_TYPES = new Set([
+    'validate',
+    'permission_check',
+    'company_branch_check',
+    'commit'
+]);
+/**
+ * Who may start a run at a Request step. `internal` (other flows only): the step has no URL - only
+ * other flows' `call_flow` steps start there, and the run takes its caller's user.
+ */ const FLOW_AUTH_MODES = [
+    'public',
+    'api_key',
+    'jwt',
+    'permission',
+    'internal'
+];
+/** A Request step that sets no access: any signed-in user. */ const DEFAULT_AUTH_MODE = 'jwt';
+/** Modes a caller reaches without signing in: the run has no `user`. */ const KEYLESS_AUTH_MODES = new Set([
+    'public',
+    'api_key'
+]);
+/** object: the body is one object and the fields are its keys (`input.<name>`). list: the body is a list and the fields describe each item (`input.0.<name>`). */ const FLOW_BODY_TYPES = [
+    'object',
+    'list'
+];
+const FLOW_INPUT_TYPES = [
+    'string',
+    'text',
+    'number',
+    'integer',
+    'boolean',
+    'date',
+    'datetime',
+    'email',
+    'uuid',
+    'object',
+    'array',
+    'choice'
+];
+/** How a step is named in messages: its name, or its id when it was left unnamed. */ const nodeLabel = (node)=>node.name || node.id;
+/** caller (default): the signed-in user. user: the user `userId` names, checked without them being signed in. */ const FLOW_ACCESS_SUBJECTS = [
+    'caller',
+    'user'
+];
+/**
+ * How a branch passes. direct (default): it is granted to the user. within: it is granted, or sits
+ * anywhere under a granted branch - a child needs no grant of its own.
+ */ const FLOW_BRANCH_MATCHES = [
+    'direct',
+    'within'
+];
+/**
+ * Which companies' branches a branch check counts. any (default): every company of the user.
+ * current: the caller's current company (not for another user, who has none).
+ */ const FLOW_BRANCH_COMPANIES = [
+    'any',
+    'current'
+];
+/**
+ * Which records a write node touches. one (default): a single record. many: one per item of `items`,
+ * whose per-record expressions read the item as `loop.item` (a loop around the node becomes
+ * `loop.parent`). filter: every record matching `filter`, read as `loop.item`.
+ */ const RECORD_WRITE_TARGETS = [
+    'one',
+    'many',
+    'filter'
+];
+function isStoredApiKey(value) {
+    const key = value;
+    return typeof key?.prefix === 'string' && typeof key.hash === 'string' && /^[0-9a-f]{64}$/.test(key.hash);
+}
+/** The app modules a message step sends through; a step whose module is not installed cannot be saved or run. */ const FLOW_MESSAGE_SERVICES = {
+    send_notification: 'notification',
+    send_email: 'email'
+};
+const isMessageNode = (type)=>Object.hasOwn(FLOW_MESSAGE_SERVICES, type);
+const FLOW_NOTIFICATION_TYPES = [
+    'info',
+    'success',
+    'warning',
+    'error'
+];
+/**
+ * Who a notification step sends to. one (default): one notification to the users `userIds` names.
+ * many: one per item of `items`, each read with the item as `loop.item`. company: every active member
+ * of `companyIds` (one or a list; with `branchIds`, only those also in one of those branches), shown under that company.
+ */ const FLOW_NOTIFICATION_TARGETS = [
+    'one',
+    'many',
+    'company'
+];
+/** one (default): one email. many: one per item of `items`, each read with the item as `loop.item`. */ const FLOW_EMAIL_TARGETS = [
+    'one',
+    'many'
+];
+const FLOW_EMAIL_MODES = [
+    'content',
+    'template'
+];
+const FLOW_EMAIL_FORMATS = [
+    'text',
+    'html'
+];
+const FLOW_LIMITS = {
+    MAX_NODES: 100,
+    MAX_EDGES: 300,
+    /** Room for a full foreach (MAX_FOREACH_ITEMS) with a few steps per item. */ MAX_STEPS_PER_RUN: 5000,
+    MAX_FOREACH_ITEMS: 1000,
+    MAX_LOOP_DEPTH: 3,
+    MAX_CALL_DEPTH: 5,
+    MAX_HTTP_CALLS: 10,
+    /** Notification and email steps sent per run (a loop counts every pass). */ MAX_MESSAGES_PER_RUN: 100,
+    MAX_NOTIFICATION_RECIPIENTS: 500,
+    /** All members of the companies a company-wide notification step reaches. */ MAX_COMPANY_NOTIFICATION_RECIPIENTS: 5000,
+    /** to + cc + bcc of one email. */ MAX_EMAIL_RECIPIENTS: 50,
+    MAX_NOTIFICATION_TITLE_LENGTH: 255,
+    MAX_EMAIL_SUBJECT_LENGTH: 255,
+    MAX_EMAIL_TEMPLATE_SLUG_LENGTH: 255,
+    MAX_HTTP_TIMEOUT_MS: 15_000,
+    MAX_HTTP_RESPONSE_BYTES: 1_000_000,
+    MAX_QUERY_LIMIT: 200,
+    MAX_WRITE_ITEMS: 1000,
+    DEFAULT_WRITE_FILTER_LIMIT: 100,
+    MAX_CHILD_INSERTS: 10,
+    MAX_WRITES_PER_RUN: 5000,
+    DEFAULT_TIMEOUT_MS: 30_000,
+    MIN_TIMEOUT_MS: 1000,
+    MAX_TIMEOUT_MS: 120_000,
+    DEFAULT_RATE_LIMIT_PER_MINUTE: 60,
+    MAX_RATE_LIMIT_PER_MINUTE: 100_000,
+    TRACE_PREVIEW_CHARS: 2000,
+    MAX_INPUT_FIELDS: 50,
+    /** How deep object/list-of-object fields may nest inside the request body. */ MAX_INPUT_DEPTH: 4,
+    MAX_VALIDATE_CHECKS: 50,
+    MAX_CODE_LENGTH: 20_000,
+    DEFAULT_CODE_TIMEOUT_MS: 1000,
+    MIN_CODE_TIMEOUT_MS: 10,
+    MAX_CODE_TIMEOUT_MS: 5000,
+    CODE_MEMORY_LIMIT_BYTES: 32 * 1024 * 1024,
+    CODE_STACK_SIZE_BYTES: 512 * 1024,
+    MAX_CODE_OUTPUT_BYTES: 1_000_000,
+    MAX_CODE_LOG_LINES: 50,
+    MAX_CODE_LOG_LINE_CHARS: 500
+};
+const FLOW_NODE_ID_PATTERN = /^[A-Za-z][A-Za-z0-9_]{0,39}$/;
+const FLOW_SLUG_PATTERN = /^[a-z][a-z0-9-]{2,62}$/;
+const FLOW_INPUT_NAME_PATTERN = /^[A-Za-z][A-Za-z0-9_]{0,59}$/;
+const FLOW_ENDPOINT_PATH_PATTERN = /^[a-z][a-z0-9-]{0,62}$/;
+/** A record, user or company id. */ const FLOW_ID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+/** Who may start a run at a Request step; an unknown mode reads as the default, which the validator refuses on save. */ function endpointAuth(config) {
+    const authMode = config.authMode && FLOW_AUTH_MODES.includes(config.authMode) ? config.authMode : DEFAULT_AUTH_MODE;
+    return {
+        authMode,
+        permissions: authMode === 'permission' ? config.permissions ?? null : null
+    };
+}
+/** A flow whose every Request step is `internal`: a function, with no URL of its own. */ const isFunctionFlow = (flow)=>{
+    const endpoints = flowEndpoints(flow);
+    return endpoints.length > 0 && endpoints.every((endpoint)=>endpoint.authMode === 'internal');
+};
+/** A Request step's path, or null when it answers on the flow's own URL. */ function triggerPath(node) {
+    const path = node.config?.path;
+    return typeof path === 'string' && path.trim() ? path.trim() : null;
+}
+/** Every Request step of a flow as a URL, with the body and access it sets. */ function flowEndpoints(flow) {
+    return (flow.nodes ?? []).filter((node)=>node?.type === 'trigger').map((node)=>{
+        const path = triggerPath(node);
+        const config = node.config ?? {};
+        return {
+            nodeId: node.id,
+            path,
+            bodyType: config.bodyType ?? 'object',
+            inputSchema: Array.isArray(config.inputSchema) ? config.inputSchema : [],
+            ...endpointAuth(config),
+            isTransactional: config.isTransactional === true,
+            timeoutMs: config.timeoutMs ?? FLOW_LIMITS.DEFAULT_TIMEOUT_MS,
+            rateLimitPerMinute: config.rateLimitPerMinute ?? FLOW_LIMITS.DEFAULT_RATE_LIMIT_PER_MINUTE,
+            apiKey: isStoredApiKey(config.apiKey) ? config.apiKey : null
+        };
+    });
+}
+/** The URL a call came in on: `path` of a Request step, or null / empty for the flow's own URL. */ function findEndpoint(flow, path) {
+    const wanted = path?.trim() || null;
+    return flowEndpoints(flow).find((endpoint)=>endpoint.path === wanted);
+}
+/** The Request step a run starts at: by its id, or the one on the flow's own URL when none is named. */ function startEndpoint(flow, nodeId) {
+    return nodeId ? flowEndpoints(flow).find((endpoint)=>endpoint.nodeId === nodeId) : findEndpoint(flow);
+}
+/** Output ports a node of this type can have (a `respond` node ends the flow: none). */ function portsOf(node) {
+    switch(node.type){
+        case 'condition':
+            return [
+                'true',
+                'false'
+            ];
+        case 'switch':
+            return [
+                ...(node.config.cases ?? []).map((c)=>c.id),
+                'default'
+            ];
+        case 'foreach':
+            return [
+                'each',
+                'done'
+            ];
+        case 'permission_check':
+        case 'company_branch_check':
+            return node.config.onDenied === 'branch' ? [
+                'allowed',
+                'denied'
+            ] : [
+                'out'
+            ];
+        case 'respond':
+            return [];
+        case 'trigger':
+        case 'validate':
+        case 'set':
+        case 'commit':
+            return [
+                'out'
+            ];
+        default:
+            return [
+                'out',
+                'error'
+            ];
+    }
+}
+
+__webpack_require__.d(__webpack_exports__, {
+  IE: () => (startEndpoint),
+  Xr: () => (flowEndpoints),
+  a5: () => (portsOf),
+  um: () => (triggerPath),
+  vS: () => (findEndpoint),
+  xA: () => (isStoredApiKey)
+}, {
+  At: NON_CONTINUABLE_NODE_TYPES,
+  B9: FLOW_EMAIL_TARGETS,
+  Dn: RECORD_WRITE_TARGETS,
+  E2: FLOW_ID_PATTERN,
+  Et: FLOW_BRANCH_MATCHES,
+  FU: FLOW_EMAIL_FORMATS,
+  KF: FLOW_MESSAGE_SERVICES,
+  LG: FLOW_NOTIFICATION_TYPES,
+  Or: FLOW_LIMITS,
+  Q7: FLOW_INPUT_TYPES,
+  SE: isMessageNode,
+  Y3: FLOW_BODY_TYPES,
+  YD: FLOW_SLUG_PATTERN,
+  YO: FLOW_ENDPOINT_PATH_PATTERN,
+  as: FLOW_NOTIFICATION_TARGETS,
+  d7: KEYLESS_AUTH_MODES,
+  dA: nodeLabel,
+  fO: FLOW_AUTH_MODES,
+  fP: isFunctionFlow,
+  fZ: FLOW_INPUT_NAME_PATTERN,
+  iM: FLOW_ACCESS_SUBJECTS,
+  q2: FLOW_NODE_TYPES,
+  sk: FLOW_BRANCH_COMPANIES,
+  v1: FLOW_EMAIL_MODES,
+  z6: FLOW_NODE_ID_PATTERN
+});
+
+
+},
+5313(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+/* import */ var node_crypto__rspack_import_0 = __webpack_require__(2561);
+/* import */ var typeorm__rspack_import_1 = __webpack_require__(7158);
+/* import */ var _enums_field_type_enum_js__rspack_import_2 = __webpack_require__(9614);
+
+
+
+/** Columns every dynamic table may carry (the `Identity` contract). Everything else is a designed field. */ const SYSTEM_COLUMN_NAMES = [
+    'id',
+    'created_at',
+    'updated_at',
+    'deleted_at',
+    'created_by_id',
+    'updated_by_id',
+    'deleted_by_id'
+];
+/** Field types stored as unbounded text or JSON: an index or unique constraint on them fails (MySQL) or breaks on large values (PostgreSQL). */ const NON_INDEXABLE_FIELD_TYPES = [
+    _enums_field_type_enum_js__rspack_import_2/* .FieldType.LONG_TEXT */.P.LONG_TEXT,
+    _enums_field_type_enum_js__rspack_import_2/* .FieldType.JSON */.P.JSON,
+    _enums_field_type_enum_js__rspack_import_2/* .FieldType.MULTI_SELECT */.P.MULTI_SELECT
+];
+const isIndexableFieldType = (fieldType)=>!NON_INDEXABLE_FIELD_TYPES.includes(fieldType);
+const uuidColumn = (name, driver, options = {})=>new typeorm__rspack_import_1.TableColumn({
+        name,
+        ...driver === 'postgres' ? {
+            type: 'uuid'
+        } : {
+            type: 'char',
+            length: '36'
+        },
+        ...options
+    });
+function buildSystemColumns(flags, driver) {
+    const columns = [
+        uuidColumn('id', driver, {
+            isPrimary: true,
+            isGenerated: true,
+            generationStrategy: 'uuid'
+        }),
+        new typeorm__rspack_import_1.TableColumn({
+            name: 'created_at',
+            type: 'timestamp',
+            isNullable: false,
+            default: 'CURRENT_TIMESTAMP'
+        }),
+        new typeorm__rspack_import_1.TableColumn({
+            name: 'updated_at',
+            type: 'timestamp',
+            isNullable: false,
+            default: 'CURRENT_TIMESTAMP'
+        })
+    ];
+    if (flags.isSoftDeleteEnabled) columns.push(softDeleteColumn());
+    if (flags.isAuditEnabled) columns.push(...auditColumns(driver));
+    return columns;
+}
+const softDeleteColumn = ()=>new typeorm__rspack_import_1.TableColumn({
+        name: 'deleted_at',
+        type: 'timestamp',
+        isNullable: true
+    });
+const auditColumns = (driver)=>[
+        uuidColumn('created_by_id', driver, {
+            isNullable: true
+        }),
+        uuidColumn('updated_by_id', driver, {
+            isNullable: true
+        }),
+        uuidColumn('deleted_by_id', driver, {
+            isNullable: true
+        })
+    ];
+const sameColumns = (columnNames, expected)=>columnNames.length === expected.length && expected.every((c)=>columnNames.includes(c));
+const NAME_HASH_LENGTH = 8;
+/**
+ * Deterministic index/constraint name within the driver's identifier limit. The hash of
+ * `table.column` keeps names distinct when the readable part is cut short, and when two
+ * table/column pairs would read the same (`eb_a_b` + `c` vs `eb_a` + `b_c`).
+ */ function indexName(prefix, table, column, maxLength) {
+    const hash = (0,node_crypto__rspack_import_0.createHash)('sha256').update(`${table}.${column}`).digest('hex').slice(0, NAME_HASH_LENGTH);
+    const room = maxLength - prefix.length - hash.length - 2;
+    return `${prefix}_${`${table}_${column}`.slice(0, room)}_${hash}`;
+}
+const plainIndex = (table, column, driver, adapter)=>new typeorm__rspack_import_1.TableIndex({
+        name: indexName('idx', table, column, adapter.maxIdentifierLength(driver)),
+        columnNames: [
+            column
+        ]
+    });
+const tableUnique = (table, column, driver, adapter)=>new typeorm__rspack_import_1.TableUnique({
+        name: indexName('uq', table, column, adapter.maxIdentifierLength(driver)),
+        columnNames: [
+            column
+        ]
+    });
+/** MySQL has no unique constraints (TypeORM refuses them), only unique indexes. */ async function addUnique(qr, table, column, driver, adapter) {
+    const name = indexName('uq', table.name, column, adapter.maxIdentifierLength(driver));
+    if (driver === 'mysql') {
+        await qr.createIndex(table, new typeorm__rspack_import_1.TableIndex({
+            name,
+            columnNames: [
+                column
+            ],
+            isUnique: true
+        }));
+        return;
+    }
+    await qr.createUniqueConstraint(table, new typeorm__rspack_import_1.TableUnique({
+        name,
+        columnNames: [
+            column
+        ]
+    }));
+}
+/** The stored column type, with a `uuid` stored before MySQL support became char(36) resolved to what MySQL accepts. */ function columnType(field, driver, adapter) {
+    const type = field.dbType || adapter.mapFieldType(field.fieldType, driver);
+    return driver === 'mysql' && type === 'uuid' ? 'char' : type;
+}
+/**
+ * Column for a field. `enforceNotNull` controls whether the DB column is NOT NULL: true when
+ * the table is brand new (no rows can violate it); false when adding to a table that already
+ * has rows (the NOT NULL is applied afterwards, once the column has been backfilled).
+ */ function buildFieldColumn(field, driver, adapter, options) {
+    const sizing = adapter.getColumnSizing(field.fieldType, driver);
+    return new typeorm__rspack_import_1.TableColumn({
+        name: field.code,
+        type: columnType(field, driver, adapter),
+        length: sizing.length,
+        precision: sizing.precision ?? undefined,
+        scale: sizing.scale,
+        isNullable: options.enforceNotNull ? field.nullable : true,
+        isUnique: options.withUnique ? field.unique : false
+    });
+}
+/** The SQL type text for a field type on a driver, e.g. `varchar(255)`, `numeric(18,4)`, `char(36)`. */ function sqlTypeFor(fieldType, driver, adapter) {
+    const base = adapter.mapFieldType(fieldType, driver);
+    const sizing = adapter.getColumnSizing(fieldType, driver);
+    if (sizing.length) return `${base}(${sizing.length})`;
+    if (sizing.precision !== undefined) return `${base}(${sizing.precision},${sizing.scale ?? 0})`;
+    return base;
+}
+/** Coarse type family, so `character varying` (pg) and `varchar` (mysql) compare equal. */ function typeFamily(type) {
+    const t = type.toLowerCase();
+    if (t === 'uuid') return 'uuid';
+    if (t.includes('json')) return 'json';
+    if (t.includes('timestamp') || t === 'datetime') return 'timestamp';
+    if (t === 'date') return 'date';
+    if (t.includes('bool') || t === 'tinyint') return 'boolean';
+    if (t.includes('int') && !t.includes('point')) return 'integer';
+    if (t.includes('numeric') || t.includes('decimal')) return 'numeric';
+    if (t.includes('char') || t === 'varchar') return 'varchar';
+    if (t.includes('text')) return 'text';
+    return t;
+}
+
+__webpack_require__.d(__webpack_exports__, {
+  $6: () => (addUnique),
+  Rm: () => (buildSystemColumns),
+  cg: () => (sqlTypeFor),
+  fu: () => (buildFieldColumn),
+  jp: () => (typeFamily),
+  mo: () => (indexName)
+}, {
+  G7: sameColumns,
+  HK: auditColumns,
+  OG: softDeleteColumn,
+  d4: isIndexableFieldType,
+  gW: NON_INDEXABLE_FIELD_TYPES,
+  mq: SYSTEM_COLUMN_NAMES,
+  uy: tableUnique,
+  v7: plainIndex
+});
+
+
 },
 6873(module) {
 
@@ -1069,6 +1621,18 @@ module.exports = __rspack_external_class_transformer_c5a479fb;
 module.exports = __rspack_external_class_validator_7b99ef4d;
 
 
+},
+2561(module) {
+
+module.exports = __rspack_external_node_crypto_2e7c4b46;
+
+
+},
+7158(module) {
+
+module.exports = __rspack_external_typeorm;
+
+
 },
 
 };