oak-db 3.3.14 → 4.0.1

package/lib/PostgreSQL/translator.js

@@ -3,10 +3,12 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.PostgreSQLTranslator = void 0;
 const tslib_1 = require("tslib");
 const assert_1 = tslib_1.__importDefault(require("assert"));
+const crypto_1 = require("crypto");
 const util_1 = require("util");
 const lodash_1 = require("lodash");
 const types_1 = require("oak-domain/lib/types");
 const sqlTranslator_1 = require("../sqlTranslator");
+const indexName_1 = require("../utils/indexName");
 const GeoTypes = [
     {
         type: 'point',
@@ -96,10 +98,103 @@ function transformGeoData(data) {
     }
 }
 class PostgreSQLTranslator extends sqlTranslator_1.SqlTranslator {
+    maxIndexNameLength = 63;
+    physicalIndexNameCache;
+    makeIndexNameCacheKey(entityName, tableName, logicalName, suffix = '') {
+        return [entityName, tableName, logicalName, suffix].join('\u0000');
+    }
+    getIndexSuffixes(index) {
+        if (index.config?.type !== 'fulltext' || !Array.isArray(index.config.tsConfig)) {
+            return [''];
+        }
+        if (index.config.tsConfig.length <= 1) {
+            return [''];
+        }
+        return index.config.tsConfig.map((lang) => `_${lang}`);
+    }
+    ensurePhysicalIndexNameCache() {
+        if (this.physicalIndexNameCache) {
+            return this.physicalIndexNameCache;
+        }
+        const entries = [];
+        for (const entityName in this.schema) {
+            const tableName = this.schema[entityName].storageName || entityName;
+            const indexes = this.schema[entityName].indexes || [];
+            for (const index of indexes) {
+                for (const suffix of this.getIndexSuffixes(index)) {
+                    const key = this.makeIndexNameCacheKey(entityName, tableName, index.name, suffix);
+                    entries.push({
+                        key,
+                        baseName: (0, indexName_1.buildCompactPhysicalIndexName)({
+                            entityName,
+                            tableName,
+                            logicalName: index.name,
+                            suffix,
+                            maxLength: this.maxIndexNameLength,
+                        }),
+                    });
+                }
+            }
+        }
+        const grouped = new Map();
+        entries.forEach(({ key, baseName }) => {
+            const bucket = grouped.get(baseName);
+            if (bucket) {
+                bucket.push(key);
+            }
+            else {
+                grouped.set(baseName, [key]);
+            }
+        });
+        const cache = new Map();
+        grouped.forEach((keys, baseName) => {
+            if (keys.length === 1) {
+                cache.set(keys[0], baseName);
+                return;
+            }
+            keys.sort();
+            keys.forEach((key) => {
+                const hash = (0, crypto_1.createHash)('sha1')
+                    .update(key)
+                    .digest('hex')
+                    .slice(0, 8);
+                const prefixLength = Math.max(1, this.maxIndexNameLength - hash.length - 1);
+                cache.set(key, `${baseName.slice(0, prefixLength)}_${hash}`);
+            });
+        });
+        this.physicalIndexNameCache = cache;
+        return cache;
+    }
     // 生成 enum 类型名称
     getEnumTypeName(entity, attr) {
         return `${entity}_${attr}_enum`.toLowerCase();
     }
+    getPhysicalIndexName(entityName, tableName, logicalName, suffix = '') {
+        const key = this.makeIndexNameCacheKey(entityName, tableName, logicalName, suffix);
+        return this.ensurePhysicalIndexNameCache().get(key)
+            || (0, indexName_1.buildCompactPhysicalIndexName)({
+                entityName,
+                tableName,
+                logicalName,
+                suffix,
+                maxLength: this.maxIndexNameLength,
+            });
+    }
+    getLegacyPhysicalIndexNames(entityName, tableName, logicalName, suffix = '') {
+        const names = (0, indexName_1.buildLegacyPhysicalIndexNames)({
+            entityName,
+            tableName,
+            logicalName,
+            suffix,
+            maxLength: this.maxIndexNameLength,
+            serverTruncatesWhenOverflow: true,
+        });
+        const currentName = this.getPhysicalIndexName(entityName, tableName, logicalName, suffix);
+        if (!names.includes(currentName)) {
+            names.push(currentName);
+        }
+        return Array.from(new Set(names));
+    }
     /**
      * 将 MySQL 风格的 JSON 路径转换为 PostgreSQL 路径数组格式
      * 例如: ".foo.bar[0].baz" -> '{foo,bar,0,baz}'
@@ -954,7 +1049,7 @@ class PostgreSQLTranslator extends sqlTranslator_1.SqlTranslator {
                         indexSql += 'IF NOT EXISTS ';
                     }
                     // 索引名称（多语言时添加后缀）
-                    indexSql += `"${String(entity)}_${name}${suffix}" ON "${tableName}" `;
+                    indexSql += `"${this.getPhysicalIndexName(String(entity), tableName, name, suffix)}" ON "${tableName}" `;
                     // 索引方法
                     if (indexType === 'hash') {
                         indexSql += 'USING HASH ';
@@ -1469,14 +1564,6 @@ class PostgreSQLTranslator extends sqlTranslator_1.SqlTranslator {
         if (typeof indexFrom === 'number' && indexFrom > 0) {
             sql += ` OFFSET ${indexFrom}`;
         }
-        // FOR UPDATE 锁定
-        if (option?.forUpdate) {
-            sql += ' FOR UPDATE';
-            if (typeof option.forUpdate === 'string') {
-                // PostgreSQL 支持: NOWAIT, SKIP LOCKED, OF table_name
-                sql += ` ${option.forUpdate}`;
-            }
-        }
         return sql;
     }
     translateUpdate(entity, operation, option) {
@@ -2004,6 +2091,35 @@ class PostgreSQLTranslator extends sqlTranslator_1.SqlTranslator {
         }
         return sql;
     }
+    translateColumnDefinition(entity, attr, attrDef) {
+        let sql = `"${attr}" `;
+        const { type, params, default: defaultValue, unique, notNull, sequenceStart, enumeration, } = attrDef;
+        if (type === 'sequence' || (typeof sequenceStart === 'number')) {
+            sql += `bigint GENERATED BY DEFAULT AS IDENTITY (START WITH ${sequenceStart || 10000}) UNIQUE`;
+            return sql;
+        }
+        if (type === 'enum') {
+            (0, assert_1.default)(enumeration, 'Enum type requires enumeration values');
+            sql += `"${this.getEnumTypeName(entity, attr)}"`;
+        }
+        else {
+            sql += this.populateDataTypeDef(type, params, enumeration);
+        }
+        if (notNull || type === 'geometry') {
+            sql += ' NOT NULL';
+        }
+        if (unique) {
+            sql += ' UNIQUE';
+        }
+        if (defaultValue !== undefined && !sequenceStart) {
+            (0, assert_1.default)(type !== 'ref', 'ref type should not have default value');
+            sql += ` DEFAULT ${this.translateAttrValue(type, defaultValue)}`;
+        }
+        if (attr === 'id') {
+            sql += ' PRIMARY KEY';
+        }
+        return sql;
+    }
     /**
      * 比较两个 SQL 语句是否等价（用于 schema diff）
      * 忽略空格、大小写等格式差异

package/lib/index.d.ts

@@ -2,3 +2,4 @@ export * from './MySQL/store';
 export { MySqlSelectOption, MysqlOperateOption } from './MySQL/translator';
 export * from './PostgreSQL/store';
 export { PostgreSQLSelectOption, PostgreSQLOperateOption } from './PostgreSQL/translator';
+export type { MigrationPlan, MigrationPlanningOptions, MigrationWarning, RenameCandidate, SchemaInspectionResult, TableStats, Plan, } from './types/migration';

package/lib/migration.d.ts

@@ -0,0 +1,27 @@
+import { Attribute } from 'oak-domain/lib/types';
+import { AttributeChangeClassification, AttributeSnapshot, MigrationEntityDict, MigrationIndexWithOrigin, MigrationSchema, MigrationPlanningOptions, IndexSnapshot, MigrationPlan, SchemaMigrationAdapter } from './types/migration';
+export declare function normalizeAttribute(attr: Attribute, options?: {
+    schema?: MigrationSchema;
+    column?: string;
+    dialect?: SchemaMigrationAdapter['dialect'];
+    compareForeignKeys?: boolean;
+}): AttributeSnapshot;
+export declare function normalizeIndex(index: MigrationIndexWithOrigin): IndexSnapshot;
+export declare function areAttributesEquivalent(oldAttr: Attribute, newAttr: Attribute, options?: {
+    oldSchema?: MigrationSchema;
+    newSchema?: MigrationSchema;
+    column?: string;
+    oldColumn?: string;
+    newColumn?: string;
+    dialect?: SchemaMigrationAdapter['dialect'];
+    compareForeignKeys?: boolean;
+}): boolean;
+export declare function areIndexesEquivalent(oldIndex: MigrationIndexWithOrigin, newIndex: MigrationIndexWithOrigin): boolean;
+export declare function classifyAttributeChange(oldAttr?: Attribute, newAttr?: Attribute, options?: {
+    oldSchema?: MigrationSchema;
+    newSchema?: MigrationSchema;
+    column?: string;
+    dialect?: SchemaMigrationAdapter['dialect'];
+    compareForeignKeys?: boolean;
+}): AttributeChangeClassification;
+export declare function buildMigrationPlan<ED extends MigrationEntityDict>(currentSchema: MigrationSchema<ED>, targetSchema: MigrationSchema<ED>, adapter: SchemaMigrationAdapter<ED>, options?: MigrationPlanningOptions): MigrationPlan<ED>;