neopg 2.0.6 → 2.0.7

package/lib/ModelChain.js

@@ -57,8 +57,8 @@ class ModelChain {
 
   _destroy() {
     this._executed = true
-    this.def = null
-    this.ctx = null
+    //this.def = null
+    //this.ctx = null
     // this.sql = null // 可选：保留引用以便 debug，或者释放
   }
 

package/lib/NeoPG.js

@@ -25,7 +25,6 @@ function toPascalCase(str) {
 class NeoPG {
   constructor(config) {
     this.driver = postgres(config)
-    this.ModelChain = ModelChain
     this.sql = this.driver
     
     this.defaultSchema = config.schema || 'public'
@@ -35,7 +34,7 @@ class NeoPG {
 
   table(tableName, schema = null) {
     const target = schema || this.defaultSchema
-    let m = new this.ModelChain(this, {tableName, isRaw: true}, target)
+    let m = new ModelChain(this, {tableName, isRaw: true}, target)
     m._isRaw = true
     return m
   }
@@ -65,7 +64,7 @@ class NeoPG {
     if (typeof input === 'function') {
       ModelClass = input
     } else {
-      ModelClass = this.ModelChain.from(input)
+      ModelClass = ModelChain.from(input)
     }
 
     const rawSchema = ModelClass.schema

package/lib/SchemaSync.js

@@ -28,7 +28,7 @@ const DataTypeMap = {
 const Numerics = ['smallint','bigint','integer','decimal','numeric', 'int'];
 const Strings = ['char', 'varchar', 'text'];
 const TypeWithBrackets = ['character varying', 'character', 'decimal', 'numeric'];
-const DefaultWithType = ['varchar', 'char', 'text', 'bytea', 'timestamp', 'timestampz', 'date', 'time'];
+const DefaultWithType = ['varchar', 'char', 'text', 'bytea', 'timestamp', 'timestamptz', 'date', 'time'];
 
 class SchemaSync {
 
@@ -47,29 +47,26 @@ class SchemaSync {
     const tableName = def.tableName;
     const curTableName = `${schema}.${tableName}`;
 
-    // [递归锁初始化] 记录本次同步过程中已经处理过的 Model，防止死循环
+    // [递归锁初始化]
     if (!options.syncedModels) {
         options.syncedModels = new Set();
     }
 
-    // 如果该表在本次递归链中已经同步过，则跳过
     if (options.syncedModels.has(def.modelName)) {
         return; 
     }
-    // 标记当前表已开始同步
     options.syncedModels.add(def.modelName);
 
     if (debug) console.log(`检测数据表 ${tableName} 的column...`);
 
-    // 0. 检查列定义的合法性 (移植自 _checkFixColumn)
-    // 简单复刻：NeoPG 的 ModelDef 已经做了一部分，这里补充检查
+    // 0. 检查列定义的合法性
     for (let k in def.columns) {
       if (k.toLowerCase() !== k) {
         console.warn(`[NeoPG Warning] ${tableName} column ${k} 包含大写，Postgres会转小写，建议代码中改为小写。`);
       }
     }
 
-    // 1. 获取 Schema OID (用于外键查询)
+    // 1. 获取 Schema OID
     let schemaOid = null;
     const nsRes = await sql`SELECT oid FROM pg_namespace WHERE nspname = ${schema}`;
     if (nsRes.length > 0) schemaOid = nsRes[0].oid;
@@ -85,7 +82,6 @@ class SchemaSync {
     // A. 表不存在 -> 创建
     if (tableInfo.length === 0) {
       await this.createTable(sql, def, schema, curTableName, debug);
-      // 同步索引、约束、外键
       await this.syncIndex(sql, def, schema, curTableName, debug);
       await this.syncUnique(sql, def, schema, curTableName, debug);
       await this.syncReferences(sql, def, schema, curTableName, schemaOid, debug, ctx, options);
@@ -93,7 +89,6 @@ class SchemaSync {
     }
 
     // B. 表存在 -> 增量同步
-    // 获取现有列信息
     const cols = await sql`
       SELECT column_name, data_type, column_default, character_maximum_length, 
              numeric_precision, numeric_scale, is_nullable, is_generated
@@ -106,11 +101,6 @@ class SchemaSync {
     const inf = {};
     for (const c of cols) inf[c.column_name] = c;
 
-    // 预处理 rename 逻辑需要
-    // 若存在 dropIndex 但是不存在 removeIndex 则指向 dropIndex (原逻辑)
-    // NeoPG 中这部分配置可能需要从 def 传递进来，假设 def.rawSchema 包含这些配置
-    // 为了简化，我们假设 def 上挂载了 extra 属性用于存储 index/unique 等非 column 配置
-
     await this.syncColumn(sql, def, inf, curTableName, debug, force, dropNotExistCol);
     await this.syncIndex(sql, def, schema, curTableName, debug);
     await this.syncUnique(sql, def, schema, curTableName, debug);
@@ -120,6 +110,22 @@ class SchemaSync {
     if (debug) console.log(` - 表结构同步完成 (${tableName}) - `);
   }
 
+  // --- [NEW] 抽取出的默认值推导逻辑 ---
+  static _ensureDefaultValue(col) {
+      // 如果已经有默认值定义，则跳过
+      if (col.default !== undefined) return;
+
+      const pt = this._parseType(col.type);
+      
+      if (col.type.includes('[')) {
+          col.default = '{}';
+      } else if (Numerics.includes(pt)) {
+          col.default = 0;
+      } else if (Strings.includes(pt)) {
+          col.default = '';
+      }
+  }
+
   // --- 创建表逻辑 ---
   static async createTable(sql, def, schema, curTableName, debug) {
     let colSqls = [];
@@ -136,13 +142,8 @@ class SchemaSync {
       } else {
         if (col.notNull !== false) line += ' not null';
 
-        // 自动检测默认值逻辑
-        let pt = this._parseType(col.type);
-        if (col.default === undefined) {
-          if (col.type.includes('[')) col.default = '{}';
-          else if (Numerics.includes(pt)) col.default = 0;
-          else if (Strings.includes(pt)) col.default = '';
-        }
+        // [Modified] 使用统一方法推导默认值
+        this._ensureDefaultValue(col);
 
         if (col.default !== undefined) {
           if (col.default === null) line += ' default null';
@@ -152,7 +153,6 @@ class SchemaSync {
       colSqls.push(line);
     }
 
-    // 联合主键
     if (Array.isArray(def.primaryKey)) {
        colSqls.push(`primary key (${def.primaryKey.join(',')})`);
     }
@@ -162,7 +162,7 @@ class SchemaSync {
     await sql.unsafe(createSql);
   }
 
-  // --- 列同步逻辑 (核心复杂逻辑) ---
+  // --- 列同步逻辑 ---
   static async syncColumn(sql, def, inf, curTableName, debug, force, dropNotExistCol) {
     const qtag = randstring(12);
     let renameTable = {};
@@ -184,7 +184,7 @@ class SchemaSync {
         const oldName = col.oldName.trim();
         if (inf[k] === undefined && inf[oldName]) {
           await sql.unsafe(`ALTER TABLE ${curTableName} RENAME ${this.fmtColName(oldName)} TO ${this.fmtColName(k)}`);
-          inf[k] = inf[oldName]; // 更新内存信息
+          inf[k] = inf[oldName];
           renameTable[oldName] = true;
         }
       }
@@ -197,12 +197,8 @@ class SchemaSync {
         let addSql = `ALTER TABLE ${curTableName} ADD COLUMN ${this.fmtColName(k)} ${col.type}`;
         if (col.notNull !== false) addSql += ' not null';
 
-        // 默认值补全
-        if (col.default === undefined) {
-          if (col.type.includes('[')) col.default = '{}';
-          else if (Numerics.includes(pt)) col.default = 0;
-          else if (Strings.includes(pt)) col.default = '';
-        }
+        // [Modified] 使用统一方法推导默认值
+        this._ensureDefaultValue(col);
 
         if (col.default !== undefined) {
             if (col.default === null) addSql += ' default null';
@@ -215,13 +211,12 @@ class SchemaSync {
       }
 
       if (col.typeLock) continue;
-      if (real_type === null) continue; // 未知类型跳过
+      if (real_type === null) continue; 
 
       // 4. Check Type Change
       if (this._compareType(inf[k], col, real_type) === false) {
         let alterSql = `ALTER TABLE ${curTableName} ALTER COLUMN ${this.fmtColName(k)} TYPE ${col.type}`;
         
-        // 特殊处理字符串转非字符串的问题
         const isDbString = inf[k].data_type === 'text' || inf[k].data_type.includes('character');
         const isTargetString = Strings.includes(this._parseType(col.type));
 
@@ -229,11 +224,20 @@ class SchemaSync {
            if (col.force) {
              // 强制重建列
              await sql.unsafe(`ALTER TABLE ${curTableName} DROP COLUMN ${this.fmtColName(k)}`);
+             
              let reAddSql = `ALTER TABLE ${curTableName} ADD COLUMN ${this.fmtColName(k)} ${col.type}`;
              if (col.notNull !== false) reAddSql += ' not null';
-             if (col.default !== undefined) reAddSql += ` default $_${qtag}_$${col.default}$_${qtag}_$`;
+             
+             // [Modified] 强制重建时，必须先推导默认值，否则 not null 会导致已有数据报错
+             this._ensureDefaultValue(col);
+
+             if (col.default !== undefined) {
+                 if (col.default === null) reAddSql += ' default null';
+                 else reAddSql += ` default $_${qtag}_$${col.default}$_${qtag}_$`;
+             }
+
              await sql.unsafe(reAddSql);
-             col.changed = true; // 标记变更，供外键处理使用
+             col.changed = true;
              continue;
            } else {
              console.error(`Error: ${k} 从字符串转向其他类型无转换规则，且未设置force选项。`);
@@ -251,13 +255,9 @@ class SchemaSync {
         }
       }
 
-      // 5. Check Default Value
+      // 5. Check Default Value (Only alter if explicitly changed or added)
       if (col.default !== undefined) {
-        // 简单比对逻辑 (注：PG存储的默认值格式可能不同，这里仅作简单触发)
-        // 实际生产中可能需要更复杂的解析，这里保留原逻辑结构
-        // 原逻辑用了 _realDefault 方法，这里我们简单处理，仅当需要时设置
         let default_val_sql = col.default === null ? 'null' : `$_${qtag}_$${col.default}$_${qtag}_$`;
-        // 这里为了简化，每次都重设默认值（开销很小），或者你需要实现 _realDefault
         await sql.unsafe(`ALTER TABLE ${curTableName} ALTER COLUMN ${this.fmtColName(k)} SET DEFAULT ${default_val_sql}`);
       }
 
@@ -266,67 +266,43 @@ class SchemaSync {
         if (inf[k].is_nullable === 'YES') {
           await sql.unsafe(`ALTER TABLE ${curTableName} ALTER COLUMN ${this.fmtColName(k)} SET NOT NULL`);
         }
-      } else {
-        if (inf[k].is_nullable === 'NO') {
-          // 难以恢复为 Nullable，跳过
-        }
       }
     }
 
     // 7. Drop Not Exist (Force Mode)
     if (dropNotExistCol) {
       for (let dbColName in inf) {
-        // 如果代码中没定义，且不是刚改名的
         if (!def.columns[dbColName] && !renameTable[dbColName]) {
-           
            const dbCol = inf[dbColName];
-
-           // [核心逻辑] 如果是数据库层面的虚拟列 (is_generated == 'ALWAYS')，豁免，不删除
            if (dbCol.is_generated === 'ALWAYS') {
              if (debug) console.log(`[NeoPG] Ignoring DB-only generated column: ${dbColName}`);
              continue;
            }
-
-           // [额外建议] 如果是 identity 列 (自增列的一种新形式)，通常也建议豁免，防止误删
-           // if (dbCol.is_identity === 'YES') continue; 
-
            if (debug) console.log(`Deleting unused column: ${dbColName}`);
            await sql.unsafe(`ALTER TABLE ${curTableName} DROP COLUMN ${this.fmtColName(dbColName)}`);
         }
       }
     }
-      /* for (let k in inf) {
-        if (!def.columns[k] && !renameTable[k]) {
-           await sql.unsafe(`ALTER TABLE ${curTableName} DROP COLUMN ${this.fmtColName(k)}`);
-        }
-      } */
   }
 
   // --- 索引同步 ---
   static async syncIndex(sql, def, schema, curTableName, debug) {
-    // 假设索引定义在 def.rawSchema.index (数组)
-    // ModelDef 需要暴露这个属性，或 def.indices
     const indices = def.index || [];
     if (!Array.isArray(indices)) return;
 
     for (const indname of indices) {
-        // 检查 removeIndex 配置
         const removeIndex = def.removeIndex || [];
         if (removeIndex.includes(indname)) continue;
 
-        // 检查列是否存在
         if (!this._checkColumnsExist(indname, def)) {
             console.error(`Index ${indname} 包含不存在的列，跳过。`);
             continue;
         }
 
-        // 检查索引是否存在
         const idxCols = indname.split(',').map(s=>s.trim()).filter(s=>s);
         const idxNamePart = idxCols.join('_');
         const targetIdxName = `${def.tableName}_${idxNamePart}_idx`;
 
-        // 使用 pg_indexes 查询
-        // 注意：pg_indexes 不支持 unsafe 拼 schema，只能查 schemaname 列
         const exist = await sql`
             SELECT * FROM pg_indexes 
             WHERE tablename = ${def.tableName} 
@@ -335,11 +311,6 @@ class SchemaSync {
         `;
 
         if (exist.length > 0) continue;
-
-        // 创建索引
-        // 支持 using gin 等 (这里简化处理，假设无特殊 using)
-        // 你的原代码有 indexType 检测，这里简单复刻
-        // let ind_using = ...
         await sql.unsafe(`CREATE INDEX ON ${curTableName} (${idxCols.map(c=>this.fmtColName(c)).join(',')})`);
     }
   }
@@ -348,12 +319,29 @@ class SchemaSync {
       const uniques = def.unique || [];
       if (!Array.isArray(uniques)) return;
 
+      const pkSet = new Set();
+      if (Array.isArray(def.primaryKey)) {
+          def.primaryKey.forEach(k => pkSet.add(k));
+      } else if (def.primaryKey) {
+          pkSet.add(def.primaryKey);
+      }
+
       for (const indname of uniques) {
           if (!this._checkColumnsExist(indname, def)) continue;
 
           const idxCols = indname.split(',').map(s=>s.trim()).filter(s=>s);
+
+          // 监测是否等于主键
+          if (pkSet.size > 0 && idxCols.length === pkSet.size) {
+              const isPk = idxCols.every(col => pkSet.has(col));
+              if (isPk) {
+                  if (debug) console.log(`[NeoPG] Unique '${indname}' matches Primary Key. Skipping.`);
+                  continue;
+              }
+          }
+
           const idxNamePart = idxCols.join('_');
-          const targetIdxName = `${def.tableName}_${idxNamePart}_idx`; // Unique 索引命名通常也遵循此规则，或有 _key 后缀，这里假设一致
+          const targetIdxName = `${def.tableName}_${idxNamePart}_idx`;
 
           const exist = await sql`
             SELECT * FROM pg_indexes 
@@ -369,7 +357,6 @@ class SchemaSync {
   }
 
   static async autoRemoveIndex(sql, def, schema, tableName, debug) {
-      // 1. 获取当前所有索引
       const allIdx = await sql`
         SELECT indexname FROM pg_indexes 
         WHERE tablename = ${tableName} 
@@ -381,7 +368,6 @@ class SchemaSync {
 
       const currentIdxNames = allIdx.map(i => i.indexname);
       
-      // 2. 计算应该保留的索引名
       const indices = def.index || [];
       const uniques = def.unique || [];
       
@@ -391,7 +377,6 @@ class SchemaSync {
       indices.forEach(n => keepSet.add(makeName(n)));
       uniques.forEach(n => keepSet.add(makeName(n)));
 
-      // 3. 差集删除
       for (const idxName of currentIdxNames) {
           if (!keepSet.has(idxName)) {
               if (debug) console.log('Auto removing index:', idxName);
@@ -402,56 +387,38 @@ class SchemaSync {
 
   // --- 外键同步 ---
   static async syncReferences(sql, def, schema, curTableName, schemaOid, debug, ctx, options) {
-      // 1. 收集定义中的外键
-      // 格式: { fkName: "xxx", createSql: "..." }
       let targetFKs = new Map();
-      const qtag = randstring(8);
-
+      
       for (let k in def.columns) {
           const col = def.columns[k];
           if (!col.ref) continue;
 
-          // 解析 ref: "ModelName:colName"
           const [refModelName, refColName] = this._parseRef(col.ref, k);
-
-          // 查找被引用的 Model 定义
-          // 假设 ctx.registry.get 返回 { Class, def }
           const targetModelItem = ctx.registry.get(refModelName);
-          
           let targetTableName = '';
 
           if (targetModelItem) {
               targetTableName = targetModelItem.def.tableName;
-              // --- [关键] 递归同步 ---
-              // 在创建外键之前，确保目标表已经存在且结构最新
               if (debug) console.log(`[Recursive Sync] Triggered by FK: ${def.modelName} -> ${refModelName}`);
-
               await this.execute(sql, targetModelItem.def, ctx, options);
           } else {
-              // 目标模型未注册，可能是直接引用的表名 (Fallback)
-              if (debug) console.warn(`[NeoPG] Referenced model '${refModelName}' not found in registry. Using as table name.`);
               targetTableName = refModelName.toLowerCase();
           }
 
-          // 准备外键 SQL
           const fkName = `${def.tableName}_${k}_fkey`;
-          
-          // 构建 REFERENCES 子句
           let refSql = `REFERENCES ${schema}.${targetTableName} (${refColName})`;
 
           if (col.refActionUpdate) refSql += ` ON UPDATE ${col.refActionUpdate}`;
-          else refSql += ` ON UPDATE CASCADE`; // 默认
+          else refSql += ` ON UPDATE CASCADE`;
 
           if (col.refActionDelete) refSql += ` ON DELETE ${col.refActionDelete}`;
-          else refSql += ` ON DELETE CASCADE`; // 默认
+          else refSql += ` ON DELETE CASCADE`;
 
           targetFKs.set(fkName, { col: k, sql: refSql, changed: col.changed });
       }
 
-      // 2. 获取数据库现有外键
       const existFKs = new Set();
       if (targetFKs.size > 0 && schemaOid) {
-          // 构建 IN 查询
           const names = Array.from(targetFKs.keys());
           const rows = await sql`
               SELECT conname FROM pg_constraint 
@@ -462,9 +429,7 @@ class SchemaSync {
           rows.forEach(r => existFKs.add(r.conname));
       }
 
-      // 3. 同步
       for (const [fkName, conf] of targetFKs) {
-          // 如果变更了列类型，必须先删后加
           if (existFKs.has(fkName) && conf.changed) {
               await sql.unsafe(`ALTER TABLE ${curTableName} DROP CONSTRAINT ${fkName}`);
               existFKs.delete(fkName);
@@ -481,11 +446,9 @@ class SchemaSync {
   // --- 辅助方法 ---
 
   static fmtColName(col) {
-      // 简单处理引用
       if (forbidColumns.quote.includes(col.toLowerCase())) {
           return `"${col}"`;
       }
-
       return `"${col}"`;
   }
 
@@ -502,8 +465,6 @@ class SchemaSync {
           return f.data_type === real_type;
       }
       
-      // 括号解析
-      // 原逻辑 _parseBrackets 
       const idx = col.type.indexOf('(');
       const brackets = idx > 0 ? col.type.substring(idx).trim() : '';
 
@@ -511,16 +472,14 @@ class SchemaSync {
          return `${f.data_type}(${f.character_maximum_length})` === `${real_type}${brackets}`;
       }
       
-      // numeric(p,s)
       if (f.data_type === 'numeric' || f.data_type === 'decimal') {
-         // 注意 PG 返回的 precision 可能是 null
          const p = f.numeric_precision;
          const s = f.numeric_scale;
-         if (!p) return `${real_type}${brackets}` === real_type; // 无精度对比
+         if (!p) return `${real_type}${brackets}` === real_type;
          return `${f.data_type}(${p},${s})` === `${real_type}${brackets}`;
       }
 
-      return false; // Fallback
+      return false;
   }
 
   static _checkColumnsExist(colsStr, def) {
@@ -534,12 +493,10 @@ class SchemaSync {
   static _parseRef(refstr, curColumn) {
       if (refstr.includes(':')) {
           const parts = refstr.split(':')
-          // 处理 Model:col 格式，取最后一部分做 col，前面做 Model
           const col = parts.pop()
           const model = parts.join(':')
           return [model, col]
       }
-
       return [refstr, curColumn]
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "neopg",
-  "version": "2.0.6",
+  "version": "2.0.7",
   "description": "orm for postgres",
   "keywords": [
     "neopg",

package/test/test-db.js

@@ -29,7 +29,9 @@ const User = {
     },
 
     mobile: {
-      type: dataTypes.STRING(16)
+      type: dataTypes.STRING(16),
+      //type: dataTypes.BIGINT,
+      force: true
     },
 
     mobile_state: {
@@ -133,7 +135,7 @@ const User = {
   //唯一索引
   unique: [
     'username',
-    'email'
+    'email', 'id'
   ]
 }