@restforgejs/platform 4.1.1 → 4.3.1

package/generators/tests/unit/lib/dbschema-kit/validator/cross-model-validator.test.js

@@ -1,512 +0,0 @@
-'use strict';
-
-const test = require('node:test');
-const assert = require('node:assert');
-
-const { validateCrossModel } = require('../../../../../lib/dbschema-kit/validator/cross-model-validator');
-
-function makeModel(tableName, opts = {}) {
-  const schemaName = opts.schemaName || null;
-  const model = {
-    schemaName,
-    tableName,
-    qualifiedName: schemaName ? `${schemaName}.${tableName}` : tableName,
-    fields: opts.fields || {},
-    primaryKey: opts.primaryKey || [],
-    indexes: [],
-    uniques: [],
-    relations: opts.relations || {},
-    checks: opts.checks || [],
-    _meta: {
-      hasSinglePkShorthand: false,
-      hasCompositePrimaryKey: false,
-      autoGeneratedRelations: []
-    }
-  };
-  if (opts.filePath) {
-    Object.defineProperty(model, '_filePath', {
-      value: opts.filePath,
-      enumerable: false,
-      writable: false,
-      configurable: false
-    });
-  }
-  return model;
-}
-
-function makeMap(models) {
-  // Convenience: keyed by qualifiedName (matches loader output post-Phase 13)
-  const map = new Map();
-  for (const m of models) {
-    map.set(m.qualifiedName, m);
-  }
-  return map;
-}
-
-test('cross-model: happy path 2 model dengan FK valid return 0 issues', () => {
-  const models = new Map();
-  models.set('category', makeModel('category', {
-    fields: { category_id: { type: 'uuid', pk: true, notnull: true } },
-    primaryKey: ['category_id']
-  }));
-  models.set('item_product', makeModel('item_product', {
-    fields: {
-      item_product_id: { type: 'uuid', pk: true, notnull: true },
-      category_id: { type: 'uuid', notnull: true }
-    },
-    primaryKey: ['item_product_id'],
-    relations: {
-      category: {
-        type: 'belongsTo',
-        target: 'category',
-        localKey: 'category_id',
-        references: 'category_id',
-        _autoGenerated: false
-      }
-    }
-  }));
-  const issues = validateCrossModel(models);
-  assert.deepStrictEqual(issues, []);
-});
-
-test('cross-model: empty Map return 0 issues', () => {
-  const issues = validateCrossModel(new Map());
-  assert.deepStrictEqual(issues, []);
-});
-
-test('cross-model: relations.target ke tabel non-existent return relation-unknown-target', () => {
-  const models = new Map();
-  models.set('item_product', makeModel('item_product', {
-    fields: {
-      item_product_id: { type: 'uuid', pk: true, notnull: true },
-      category_id: { type: 'uuid' }
-    },
-    primaryKey: ['item_product_id'],
-    relations: {
-      category: {
-        type: 'belongsTo',
-        target: 'category',
-        localKey: 'category_id',
-        references: 'category_id'
-      }
-    }
-  }));
-  const issues = validateCrossModel(models);
-  assert.strictEqual(issues.length, 1);
-  assert.strictEqual(issues[0].severity, 'error');
-  assert.strictEqual(issues[0].code, 'relation-unknown-target');
-  assert.strictEqual(issues[0].table, 'item_product');
-  assert.strictEqual(issues[0].relation, 'category');
-  assert.match(
-    issues[0].message,
-    /^Table 'item_product': relation 'category' targets unknown table 'category'$/
-  );
-});
-
-test('cross-model: relations.references ke field non-existent di target return relation-unknown-references-field', () => {
-  const models = new Map();
-  models.set('category', makeModel('category', {
-    fields: { category_id: { type: 'uuid', pk: true, notnull: true } },
-    primaryKey: ['category_id']
-  }));
-  models.set('item_product', makeModel('item_product', {
-    fields: {
-      item_product_id: { type: 'uuid', pk: true, notnull: true },
-      category_id: { type: 'uuid' }
-    },
-    primaryKey: ['item_product_id'],
-    relations: {
-      category: {
-        type: 'belongsTo',
-        target: 'category',
-        localKey: 'category_id',
-        references: 'nonexistent_field'
-      }
-    }
-  }));
-  const issues = validateCrossModel(models);
-  assert.strictEqual(issues.length, 1);
-  assert.strictEqual(issues[0].code, 'relation-unknown-references-field');
-  assert.match(
-    issues[0].message,
-    /^Table 'item_product': relation 'category' references unknown field 'nonexistent_field' in target table 'category'$/
-  );
-});
-
-test('cross-model: belongsTo references ke field non-PK di target return relation-not-primary-key', () => {
-  const models = new Map();
-  models.set('category', makeModel('category', {
-    fields: {
-      category_id: { type: 'uuid', pk: true, notnull: true },
-      category_name: { type: 'string', length: 100 }
-    },
-    primaryKey: ['category_id']
-  }));
-  models.set('item_product', makeModel('item_product', {
-    fields: {
-      item_product_id: { type: 'uuid', pk: true, notnull: true },
-      cat_name: { type: 'string', length: 100 }
-    },
-    primaryKey: ['item_product_id'],
-    relations: {
-      category: {
-        type: 'belongsTo',
-        target: 'category',
-        localKey: 'cat_name',
-        references: 'category_name'
-      }
-    }
-  }));
-  const issues = validateCrossModel(models);
-  assert.strictEqual(issues.length, 1);
-  assert.strictEqual(issues[0].code, 'relation-not-primary-key');
-  assert.match(
-    issues[0].message,
-    /^Table 'item_product': relation 'category' references field 'category_name' in 'category' which is not a primary key$/
-  );
-});
-
-test('cross-model: belongsTo references ke salah satu field di composite PK target return 0 issues', () => {
-  const models = new Map();
-  models.set('inventory_balance', makeModel('inventory_balance', {
-    fields: {
-      item_product_id: { type: 'uuid', notnull: true },
-      warehouse_id: { type: 'uuid', notnull: true },
-      period_date: { type: 'date', notnull: true }
-    },
-    primaryKey: ['item_product_id', 'warehouse_id', 'period_date']
-  }));
-  models.set('stock_movement', makeModel('stock_movement', {
-    fields: {
-      stock_movement_id: { type: 'uuid', pk: true, notnull: true },
-      item_product_id: { type: 'uuid' }
-    },
-    primaryKey: ['stock_movement_id'],
-    relations: {
-      balance: {
-        type: 'belongsTo',
-        target: 'inventory_balance',
-        localKey: 'item_product_id',
-        references: 'item_product_id'
-      }
-    }
-  }));
-  const issues = validateCrossModel(models);
-  assert.deepStrictEqual(issues, []);
-});
-
-test('cross-model: hasMany inverse opsional, parent punya hasMany child tanpa belongsTo return 0 issues', () => {
-  const models = new Map();
-  models.set('supplier', makeModel('supplier', {
-    fields: { supplier_id: { type: 'uuid', pk: true, notnull: true } },
-    primaryKey: ['supplier_id'],
-    relations: {
-      inbound_transactions: {
-        type: 'hasMany',
-        target: 'stock_inbound',
-        localKey: 'supplier_id',
-        references: 'supplier_id'
-      }
-    }
-  }));
-  models.set('stock_inbound', makeModel('stock_inbound', {
-    fields: {
-      stock_inbound_id: { type: 'uuid', pk: true, notnull: true },
-      supplier_id: { type: 'uuid' }
-    },
-    primaryKey: ['stock_inbound_id']
-    // Sengaja tidak ada belongsTo balik ke supplier — kebijakan inverse opsional.
-  }));
-  const issues = validateCrossModel(models);
-  assert.deepStrictEqual(issues, []);
-});
-
-test('cross-model: hasMany ke target non-existent return relation-unknown-target (rule universal lintas relation type)', () => {
-  const models = new Map();
-  models.set('supplier', makeModel('supplier', {
-    fields: { supplier_id: { type: 'uuid', pk: true, notnull: true } },
-    primaryKey: ['supplier_id'],
-    relations: {
-      inbound_transactions: {
-        type: 'hasMany',
-        target: 'nonexistent_table',
-        localKey: 'supplier_id',
-        references: 'supplier_id'
-      }
-    }
-  }));
-  const issues = validateCrossModel(models);
-  assert.strictEqual(issues.length, 1);
-  assert.strictEqual(issues[0].code, 'relation-unknown-target');
-  assert.match(
-    issues[0].message,
-    /^Table 'supplier': relation 'inbound_transactions' targets unknown table 'nonexistent_table'$/
-  );
-});
-
-// =====================================================
-// Phase 13: schema namespace support
-// =====================================================
-
-test('cross-model: relation target qualified resolve ke model exact match', () => {
-  const models = makeMap([
-    makeModel('categories', {
-      schemaName: 'inventory',
-      fields: { category_id: { type: 'uuid', pk: true, notnull: true } },
-      primaryKey: ['category_id']
-    }),
-    makeModel('products', {
-      schemaName: 'inventory',
-      fields: {
-        product_id: { type: 'uuid', pk: true, notnull: true },
-        category_id: { type: 'uuid', notnull: true }
-      },
-      primaryKey: ['product_id'],
-      relations: {
-        category: {
-          type: 'belongsTo',
-          target: 'inventory.categories',
-          localKey: 'category_id',
-          references: 'category_id',
-          _autoGenerated: false
-        }
-      }
-    })
-  ]);
-  const issues = validateCrossModel(models);
-  assert.deepStrictEqual(issues, []);
-  const productsRel = models.get('inventory.products').relations.category;
-  assert.strictEqual(productsRel._targetSchemaName, 'inventory');
-  assert.strictEqual(productsRel._targetTableName, 'categories');
-  assert.strictEqual(productsRel.target, 'inventory.categories', 'target di-rewrite ke qualified form');
-});
-
-test('cross-model: relation target unqualified resolve ke model di same schema (locality first)', () => {
-  const models = makeMap([
-    makeModel('categories', {
-      schemaName: 'inventory',
-      fields: { category_id: { type: 'uuid', pk: true, notnull: true } },
-      primaryKey: ['category_id']
-    }),
-    makeModel('products', {
-      schemaName: 'inventory',
-      fields: {
-        product_id: { type: 'uuid', pk: true, notnull: true },
-        category_id: { type: 'uuid', notnull: true }
-      },
-      primaryKey: ['product_id'],
-      relations: {
-        category: {
-          type: 'belongsTo',
-          target: 'categories',
-          localKey: 'category_id',
-          references: 'category_id',
-          _autoGenerated: false
-        }
-      }
-    })
-  ]);
-  const issues = validateCrossModel(models);
-  assert.deepStrictEqual(issues, []);
-  const rel = models.get('inventory.products').relations.category;
-  assert.strictEqual(rel.target, 'inventory.categories', 'unqualified target resolve ke same-schema');
-});
-
-test('cross-model: relation target unqualified ambigu return relation-ambiguous-target', () => {
-  const models = makeMap([
-    makeModel('categories', {
-      schemaName: 'inventory',
-      fields: { category_id: { type: 'uuid', pk: true, notnull: true } },
-      primaryKey: ['category_id']
-    }),
-    makeModel('categories', {
-      schemaName: 'public',
-      fields: { category_id: { type: 'uuid', pk: true, notnull: true } },
-      primaryKey: ['category_id']
-    }),
-    makeModel('events', {
-      schemaName: 'audit',
-      fields: {
-        event_id: { type: 'uuid', pk: true, notnull: true },
-        category_id: { type: 'uuid' }
-      },
-      primaryKey: ['event_id'],
-      relations: {
-        category: {
-          type: 'belongsTo',
-          target: 'categories',
-          localKey: 'category_id',
-          references: 'category_id',
-          _autoGenerated: false
-        }
-      }
-    })
-  ]);
-  const issues = validateCrossModel(models);
-  assert.strictEqual(issues.length, 1);
-  assert.strictEqual(issues[0].code, 'relation-ambiguous-target');
-  assert.match(
-    issues[0].message,
-    /^Table 'audit\.events': relation 'category' target 'categories' is ambiguous, found in: inventory\.categories, public\.categories\. Use qualified target like 'inventory\.categories'\.$/
-  );
-});
-
-test('cross-model: relation target unqualified resolve ke null-schema model bila source juga null-schema', () => {
-  const models = makeMap([
-    makeModel('categories', {
-      fields: { category_id: { type: 'uuid', pk: true, notnull: true } },
-      primaryKey: ['category_id']
-    }),
-    makeModel('products', {
-      fields: {
-        product_id: { type: 'uuid', pk: true, notnull: true },
-        category_id: { type: 'uuid' }
-      },
-      primaryKey: ['product_id'],
-      relations: {
-        category: {
-          type: 'belongsTo',
-          target: 'categories',
-          localKey: 'category_id',
-          references: 'category_id',
-          _autoGenerated: false
-        }
-      }
-    })
-  ]);
-  const issues = validateCrossModel(models);
-  assert.deepStrictEqual(issues, []);
-  const rel = models.get('products').relations.category;
-  assert.strictEqual(rel.target, 'categories');
-  assert.strictEqual(rel._targetSchemaName, null);
-});
-
-test('cross-model: relation target qualified tidak exist return relation-unknown-target', () => {
-  const models = makeMap([
-    makeModel('products', {
-      schemaName: 'inventory',
-      fields: {
-        product_id: { type: 'uuid', pk: true, notnull: true },
-        category_id: { type: 'uuid' }
-      },
-      primaryKey: ['product_id'],
-      relations: {
-        category: {
-          type: 'belongsTo',
-          target: 'inventory.categories',
-          localKey: 'category_id',
-          references: 'category_id'
-        }
-      }
-    })
-  ]);
-  const issues = validateCrossModel(models);
-  assert.strictEqual(issues.length, 1);
-  assert.strictEqual(issues[0].code, 'relation-unknown-target');
-  assert.match(
-    issues[0].message,
-    /^Table 'inventory\.products': relation 'category' targets unknown table 'inventory\.categories'$/
-  );
-});
-
-// =====================================================
-// Collect-errors behavior (Phase 1 refactor)
-// =====================================================
-
-test('cross-model: multiple errors di-collect, tidak short-circuit pada error pertama', () => {
-  const models = new Map();
-  models.set('a', makeModel('a', {
-    fields: {
-      a_id: { type: 'uuid', pk: true, notnull: true },
-      b_id: { type: 'uuid' }
-    },
-    primaryKey: ['a_id'],
-    relations: {
-      // Error 1: target tidak exist
-      missing_b: {
-        type: 'belongsTo',
-        target: 'b_table_not_exist',
-        localKey: 'b_id',
-        references: 'b_id'
-      }
-    }
-  }));
-  models.set('c', makeModel('c', {
-    fields: {
-      c_id: { type: 'uuid', pk: true, notnull: true },
-      d_id: { type: 'uuid' }
-    },
-    primaryKey: ['c_id'],
-    relations: {
-      // Error 2: target tidak exist (relation lain di model lain)
-      missing_d: {
-        type: 'belongsTo',
-        target: 'd_table_not_exist',
-        localKey: 'd_id',
-        references: 'd_id'
-      }
-    }
-  }));
-  const issues = validateCrossModel(models);
-  assert.strictEqual(issues.length, 2);
-  assert.strictEqual(issues[0].code, 'relation-unknown-target');
-  assert.strictEqual(issues[1].code, 'relation-unknown-target');
-});
-
-test('cross-model: Issue di-decorate dengan file path bila _filePath ada di model', () => {
-  const models = new Map();
-  models.set('a', makeModel('a', {
-    filePath: '/abs/path/a.js',
-    fields: {
-      a_id: { type: 'uuid', pk: true, notnull: true },
-      b_id: { type: 'uuid' }
-    },
-    primaryKey: ['a_id'],
-    relations: {
-      missing_b: {
-        type: 'belongsTo',
-        target: 'b_table_not_exist',
-        localKey: 'b_id',
-        references: 'b_id'
-      }
-    }
-  }));
-  const issues = validateCrossModel(models);
-  assert.strictEqual(issues.length, 1);
-  assert.strictEqual(issues[0].file, '/abs/path/a.js');
-  assert.strictEqual(issues[0].table, 'a');
-  assert.strictEqual(issues[0].relation, 'missing_b');
-});
-
-test('cross-model: target resolved tapi references field unknown — augmentation tetap terjadi', () => {
-  const models = new Map();
-  models.set('category', makeModel('category', {
-    fields: { category_id: { type: 'uuid', pk: true, notnull: true } },
-    primaryKey: ['category_id']
-  }));
-  const product = makeModel('item_product', {
-    fields: {
-      item_product_id: { type: 'uuid', pk: true, notnull: true },
-      category_id: { type: 'uuid' }
-    },
-    primaryKey: ['item_product_id'],
-    relations: {
-      category: {
-        type: 'belongsTo',
-        target: 'category',
-        localKey: 'category_id',
-        references: 'nonexistent_field'
-      }
-    }
-  });
-  models.set('item_product', product);
-
-  const issues = validateCrossModel(models);
-  assert.strictEqual(issues.length, 1);
-  assert.strictEqual(issues[0].code, 'relation-unknown-references-field');
-
-  // Augmentation must still happen so downstream validators (Phase 2+) can read rel.target
-  const rel = product.relations.category;
-  assert.strictEqual(rel.target, 'category');
-  assert.strictEqual(rel._targetTableName, 'category');
-});