@restforgejs/platform 4.1.1 → 4.3.1

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

@@ -1,443 +0,0 @@
-'use strict';
-
-const test = require('node:test');
-const assert = require('node:assert');
-
-const { buildIR } = require('../../../../../lib/dbschema-kit/ir-builder');
-const { validateSchema } = require('../../../../../lib/dbschema-kit/validator/schema-validator');
-
-// =====================================================
-// Group 1: Table Level
-// =====================================================
-
-test('validator: tableName snake_case + ada PK tidak throw', () => {
-  const ir = buildIR('stock_inbound', { fields: { id: 'uuid pk' } });
-  assert.doesNotThrow(() => validateSchema(ir));
-});
-
-test('validator: tableName mengandung uppercase harus throw', () => {
-  const ir = buildIR('StockInbound', { fields: { id: 'uuid pk' } });
-  assert.throws(
-    () => validateSchema(ir),
-    /^Error: Table name must be snake_case \(lowercase, alphanumeric, underscore, no leading digit\)$/
-  );
-});
-
-test('validator: tableName leading digit harus throw', () => {
-  const ir = buildIR('1foo', { fields: { id: 'uuid pk' } });
-  assert.throws(
-    () => validateSchema(ir),
-    /^Error: Table name must be snake_case \(lowercase, alphanumeric, underscore, no leading digit\)$/
-  );
-});
-
-test("validator: konflik 'pk' shorthand + 'primaryKey' option harus throw", () => {
-  const ir = buildIR('foo', {
-    fields: { a: 'uuid pk', b: 'uuid' },
-    primaryKey: ['a', 'b']
-  });
-  assert.throws(
-    () => validateSchema(ir),
-    /^Error: Table 'foo': cannot use 'pk' shorthand together with 'primaryKey' option$/
-  );
-});
-
-// =====================================================
-// Group 2: Field References Existence
-// =====================================================
-
-test('validator: primaryKey reference field tidak existing harus throw', () => {
-  const ir = buildIR('foo', {
-    fields: { a: 'uuid', b: 'uuid' },
-    primaryKey: ['a', 'nonexistent']
-  });
-  assert.throws(
-    () => validateSchema(ir),
-    /^Error: Table 'foo': primaryKey references unknown field 'nonexistent'$/
-  );
-});
-
-test('validator: indexes reference field tidak existing harus throw', () => {
-  const ir = buildIR('foo', {
-    fields: { id: 'uuid pk', name: 'string:50' },
-    indexes: ['nonexistent']
-  });
-  assert.throws(
-    () => validateSchema(ir),
-    /^Error: Table 'foo': index references unknown field 'nonexistent'$/
-  );
-});
-
-test('validator: uniques reference field tidak existing harus throw', () => {
-  const ir = buildIR('foo', {
-    fields: { id: 'uuid pk', a: 'string:50' },
-    uniques: [['a', 'nonexistent']]
-  });
-  assert.throws(
-    () => validateSchema(ir),
-    /^Error: Table 'foo': unique constraint references unknown field 'nonexistent'$/
-  );
-});
-
-test('validator: relations.localKey reference field tidak existing harus throw', () => {
-  const ir = buildIR('foo', {
-    fields: { id: 'uuid pk' },
-    relations: {
-      bar: { type: 'belongsTo', localKey: 'nonexistent_field', references: 'id' }
-    }
-  });
-  assert.throws(
-    () => validateSchema(ir),
-    /^Error: Table 'foo': relation 'bar' references unknown field 'nonexistent_field'$/
-  );
-});
-
-test('validator: checks.field reference field tidak existing harus throw', () => {
-  const ir = buildIR('foo', {
-    fields: { id: 'uuid pk' },
-    checks: [{ field: 'nonexistent', gt: 0 }]
-  });
-  assert.throws(
-    () => validateSchema(ir),
-    /^Error: Table 'foo': check at index 0 references unknown field 'nonexistent'$/
-  );
-});
-
-// =====================================================
-// Group 3: Relations
-// =====================================================
-
-test('validator: relation tanpa type atau type invalid harus throw', () => {
-  const ir = buildIR('foo', {
-    fields: { id: 'uuid pk', a: 'uuid' },
-    relations: {
-      bar: { localKey: 'a', references: 'id' }
-    }
-  });
-  assert.throws(
-    () => validateSchema(ir),
-    /^Error: Table 'foo': relation 'bar' has invalid or missing type 'undefined'$/
-  );
-
-  const ir2 = buildIR('foo', {
-    fields: { id: 'uuid pk', a: 'uuid' },
-    relations: {
-      bar: { type: 'belongsToMany', localKey: 'a', references: 'id' }
-    }
-  });
-  assert.throws(
-    () => validateSchema(ir2),
-    /^Error: Table 'foo': relation 'bar' has invalid or missing type 'belongsToMany'$/
-  );
-});
-
-test('validator: relation tanpa localKey harus throw', () => {
-  const ir = buildIR('foo', {
-    fields: { id: 'uuid pk' },
-    relations: {
-      bar: { type: 'belongsTo', references: 'id' }
-    }
-  });
-  assert.throws(
-    () => validateSchema(ir),
-    /^Error: Table 'foo': relation 'bar' missing 'localKey' property$/
-  );
-});
-
-test('validator: relation tanpa references harus throw', () => {
-  const ir = buildIR('foo', {
-    fields: { id: 'uuid pk', a: 'uuid' },
-    relations: {
-      bar: { type: 'belongsTo', localKey: 'a' }
-    }
-  });
-  assert.throws(
-    () => validateSchema(ir),
-    /^Error: Table 'foo': relation 'bar' missing 'references' property$/
-  );
-});
-
-test('validator: invalid onDelete value harus throw', () => {
-  const ir = buildIR('foo', {
-    fields: { id: 'uuid pk', a: 'uuid' },
-    relations: {
-      bar: { type: 'belongsTo', localKey: 'a', references: 'id', onDelete: 'set null' }
-    }
-  });
-  assert.throws(
-    () => validateSchema(ir),
-    /^Error: Table 'foo': relation 'bar' has invalid onDelete 'set null'$/
-  );
-
-  const ir2 = buildIR('foo', {
-    fields: { id: 'uuid pk', a: 'uuid' },
-    relations: {
-      bar: { type: 'belongsTo', localKey: 'a', references: 'id', onDelete: 'SET_NULL' }
-    }
-  });
-  assert.throws(
-    () => validateSchema(ir2),
-    /^Error: Table 'foo': relation 'bar' has invalid onDelete 'SET_NULL'$/
-  );
-});
-
-test('validator: invalid onUpdate value harus throw', () => {
-  const ir = buildIR('foo', {
-    fields: { id: 'uuid pk', a: 'uuid' },
-    relations: {
-      bar: { type: 'belongsTo', localKey: 'a', references: 'id', onUpdate: 'cascadex' }
-    }
-  });
-  assert.throws(
-    () => validateSchema(ir),
-    /^Error: Table 'foo': relation 'bar' has invalid onUpdate 'cascadex'$/
-  );
-});
-
-test("validator: mutual exclusivity 'fk:' shorthand + relations[*].localKey harus throw", () => {
-  const ir = buildIR('item_product', {
-    fields: {
-      id: 'uuid pk',
-      category_id: 'string:36 fk:category.category_id'
-    },
-    relations: {
-      category: {
-        type: 'belongsTo',
-        localKey: 'category_id',
-        references: 'category_id',
-        onDelete: 'cascade'
-      }
-    }
-  });
-  assert.throws(
-    () => validateSchema(ir),
-    /^Error: Table 'item_product': field 'category_id' has 'fk:' shorthand and is also referenced by relation 'category'\. Use only one declaration method\.$/
-  );
-});
-
-test("validator: auto-generated relation dengan suffix '_auto' harus throw collision", () => {
-  const ir = buildIR('foo', {
-    fields: {
-      id: 'uuid pk',
-      b_id: 'string:36 fk:b_table.id',
-      other: 'uuid'
-    },
-    relations: {
-      b: { type: 'belongsTo', localKey: 'other', references: 'id' }
-    }
-  });
-  assert.throws(
-    () => validateSchema(ir),
-    /^Error: Table 'foo': auto-generated relation name 'b' from field 'b_id' conflicts with explicit relation 'b'\. Rename one of them\.$/
-  );
-});
-
-test('validator: duplikat localKey di dua relations eksplisit harus throw', () => {
-  const ir = buildIR('foo', {
-    fields: { id: 'uuid pk', a: 'uuid' },
-    relations: {
-      rel1: { type: 'belongsTo', localKey: 'a', references: 'id' },
-      rel2: { type: 'belongsTo', localKey: 'a', references: 'id' }
-    }
-  });
-  assert.throws(
-    () => validateSchema(ir),
-    /^Error: Table 'foo': field 'a' is referenced by multiple relations: rel1, rel2$/
-  );
-});
-
-// =====================================================
-// Group 4: Checks
-// =====================================================
-
-test("validator: check dengan _invalid 'multiple operators' harus throw", () => {
-  const ir = buildIR('foo', {
-    fields: { id: 'uuid pk', x: 'integer' },
-    checks: [{ field: 'x', gt: 0, lt: 100 }]
-  });
-  assert.throws(
-    () => validateSchema(ir),
-    /^Error: Table 'foo': check at index 0 has multiple operators \(use one of: in, gt, gte, lt, lte, eq, neq\)$/
-  );
-});
-
-test("validator: check dengan _invalid 'no operator' harus throw", () => {
-  const ir = buildIR('foo', {
-    fields: { id: 'uuid pk', x: 'integer' },
-    checks: [{ field: 'x' }]
-  });
-  assert.throws(
-    () => validateSchema(ir),
-    /^Error: Table 'foo': check at index 0 must have exactly one operator \(use one of: in, gt, gte, lt, lte, eq, neq\)$/
-  );
-});
-
-test("validator: operator 'in' value bukan array atau array kosong harus throw", () => {
-  const ir = buildIR('foo', {
-    fields: { id: 'uuid pk', status: 'string:20' },
-    checks: [{ field: 'status', in: 'draft' }]
-  });
-  assert.throws(
-    () => validateSchema(ir),
-    /^Error: Table 'foo': check at index 0 operator 'in' requires non-empty array of values$/
-  );
-
-  const ir2 = buildIR('foo', {
-    fields: { id: 'uuid pk', status: 'string:20' },
-    checks: [{ field: 'status', in: [] }]
-  });
-  assert.throws(
-    () => validateSchema(ir2),
-    /^Error: Table 'foo': check at index 0 operator 'in' requires non-empty array of values$/
-  );
-});
-
-test("validator: operator 'gt' value non-number harus throw", () => {
-  const ir = buildIR('foo', {
-    fields: { id: 'uuid pk', x: 'integer' },
-    checks: [{ field: 'x', gt: '0' }]
-  });
-  assert.throws(
-    () => validateSchema(ir),
-    /^Error: Table 'foo': check at index 0 operator 'gt' requires numeric value, got 'string'$/
-  );
-});
-
-// =====================================================
-// Group 5: AutoUpdate
-// =====================================================
-
-test("validator: autoUpdate di field type 'string' harus throw", () => {
-  const ir = buildIR('foo', {
-    fields: {
-      id: 'uuid pk',
-      name: 'string:50 autoUpdate'
-    }
-  });
-  assert.throws(
-    () => validateSchema(ir),
-    /^Error: Table 'foo': field 'name' constraint 'autoUpdate' only valid for type 'timestamp' or 'date', got 'string'$/
-  );
-});
-
-test("validator: autoUpdate di field type 'integer' harus throw", () => {
-  const ir = buildIR('foo', {
-    fields: {
-      id: 'uuid pk',
-      counter: 'integer autoUpdate'
-    }
-  });
-  assert.throws(
-    () => validateSchema(ir),
-    /^Error: Table 'foo': field 'counter' constraint 'autoUpdate' only valid for type 'timestamp' or 'date', got 'integer'$/
-  );
-});
-
-test("validator: autoUpdate + default:now() di field timestamp harus throw", () => {
-  const ir = buildIR('foo', {
-    fields: {
-      id: 'uuid pk',
-      updated_at: 'timestamp default:now() autoUpdate'
-    }
-  });
-  assert.throws(
-    () => validateSchema(ir),
-    /^Error: Table 'foo': field 'updated_at' constraint 'autoUpdate' cannot be combined with 'default:'$/
-  );
-});
-
-// =====================================================
-// Bonus: Complex valid schema
-// =====================================================
-
-test('validator: schema valid kompleks (multiple relations, indexes, uniques, checks) tidak throw', () => {
-  const ir = buildIR('stock_inbound_item', {
-    fields: {
-      stock_inbound_item_id: 'uuid pk',
-      stock_inbound_id: 'uuid notnull',
-      line_number: 'integer notnull',
-      item_product_id: 'uuid notnull',
-      qty_received: 'decimal:15,0 notnull default:0',
-      uom: "string:10 default:'pcs'",
-      unit_price: 'decimal:15,2 default:0',
-      total_amount: 'decimal:15,2 default:0',
-      status: "string:20 default:'draft'",
-      notes: 'text',
-      created_at: 'timestamp',
-      updated_at: 'timestamp autoUpdate'
-    },
-    uniques: [['stock_inbound_id', 'line_number']],
-    indexes: ['stock_inbound_id', 'item_product_id', ['stock_inbound_id', 'item_product_id']],
-    relations: {
-      header: {
-        type: 'belongsTo',
-        target: 'stock_inbound',
-        localKey: 'stock_inbound_id',
-        references: 'stock_inbound_id',
-        onDelete: 'cascade'
-      },
-      product: {
-        type: 'belongsTo',
-        target: 'item_product',
-        localKey: 'item_product_id',
-        references: 'item_product_id',
-        onDelete: 'restrict'
-      }
-    },
-    checks: [
-      { field: 'status', in: ['draft', 'confirmed', 'closed', 'cancelled'] },
-      { field: 'line_number', gt: 0 },
-      { field: 'unit_price', gte: 0 }
-    ]
-  });
-  let result;
-  assert.doesNotThrow(() => {
-    result = validateSchema(ir);
-  });
-  assert.strictEqual(result, undefined, 'validateSchema returns undefined on success');
-});
-
-// =====================================================
-// Phase 13: schema namespace support
-// =====================================================
-
-test('validator: schema valid (snake_case) tidak throw, IR berisi schemaName', () => {
-  const ir = buildIR('products', {
-    schema: 'inventory',
-    fields: { id: 'uuid pk' }
-  });
-  assert.doesNotThrow(() => validateSchema(ir));
-  assert.strictEqual(ir.schemaName, 'inventory');
-  assert.strictEqual(ir.qualifiedName, 'inventory.products');
-});
-
-test('validator: schema mengandung uppercase atau hyphen harus throw', () => {
-  const ir = buildIR('products', {
-    schema: 'INVALID-NAME',
-    fields: { id: 'uuid pk' }
-  });
-  assert.throws(
-    () => validateSchema(ir),
-    /^Error: Table 'INVALID-NAME\.products': invalid schema name 'INVALID-NAME'$/
-  );
-});
-
-test('validator: schema empty string harus throw', () => {
-  // Empty string is treated as null by IR builder (default null), so it does NOT throw.
-  // Use explicit invalid string for the negative test.
-  const ir = buildIR('products', {
-    schema: '_starts_with_underscore',
-    fields: { id: 'uuid pk' }
-  });
-  assert.throws(
-    () => validateSchema(ir),
-    /^Error: Table '_starts_with_underscore\.products': invalid schema name '_starts_with_underscore'$/
-  );
-});
-
-test('validator: tanpa schema → IR.schemaName null, qualifiedName == tableName, no error', () => {
-  const ir = buildIR('products', { fields: { id: 'uuid pk' } });
-  assert.strictEqual(ir.schemaName, null);
-  assert.strictEqual(ir.qualifiedName, 'products');
-  assert.doesNotThrow(() => validateSchema(ir));
-});