@restforgejs/platform 4.1.1 → 4.3.1

package/generators/tests/unit/lib/dbschema-kit/emitters/create-index.test.js

@@ -1,173 +0,0 @@
-'use strict';
-
-const test = require('node:test');
-const assert = require('node:assert');
-
-const { defineModel } = require('../../../../../lib/dbschema-kit/define-model');
-const { getDialect } = require('../../../../../lib/dbschema-kit/dialect');
-const { collectIndexes, emitCreateIndexes } = require('../../../../../lib/dbschema-kit/emitters/create-index');
-
-const pg = getDialect('postgres');
-const mysql = getDialect('mysql');
-const sqlite = getDialect('sqlite');
-
-test('create-index: auto-emit index untuk field yang menjadi localKey FK belongsTo', () => {
-  const ir = defineModel('stock_inbound', {
-    fields: {
-      stock_inbound_id: 'string:36 pk',
-      warehouse_id: 'string:36 notnull'
-    },
-    relations: {
-      warehouse: { type: 'belongsTo', localKey: 'warehouse_id', references: 'warehouse_id' }
-    }
-  });
-
-  const collected = collectIndexes(ir);
-  assert.strictEqual(collected.length, 1);
-  assert.deepStrictEqual(collected[0].columns, ['warehouse_id']);
-  assert.strictEqual(collected[0].name, 'idx_stock_inbound_warehouse_id');
-
-  const stmts = emitCreateIndexes(ir, pg);
-  assert.deepStrictEqual(stmts, [
-    'CREATE INDEX idx_stock_inbound_warehouse_id ON stock_inbound (warehouse_id)'
-  ]);
-});
-
-test('create-index: user-declared single column index lewat opsi indexes', () => {
-  const ir = defineModel('orders', {
-    fields: {
-      order_id: 'string:36 pk',
-      status: 'string:20 notnull'
-    },
-    indexes: ['status']
-  });
-
-  const stmts = emitCreateIndexes(ir, pg);
-  assert.deepStrictEqual(stmts, [
-    'CREATE INDEX idx_orders_status ON orders (status)'
-  ]);
-});
-
-test('create-index: user-declared composite index emit composite CREATE INDEX dengan multiple columns', () => {
-  const ir = defineModel('audit', {
-    fields: {
-      audit_id: 'string:36 pk',
-      user_id: 'string:36 notnull',
-      action_at: 'timestamp notnull'
-    },
-    indexes: [['user_id', 'action_at']]
-  });
-
-  const stmts = emitCreateIndexes(ir, pg);
-  assert.strictEqual(stmts.length, 1);
-  assert.match(stmts[0], /CREATE INDEX idx_audit_user_id_action_at ON audit \(user_id, action_at\)/);
-});
-
-test('create-index: skip-emit untuk kolom dengan unique shorthand karena UNIQUE constraint sudah implicit indexed', () => {
-  const ir = defineModel('users', {
-    fields: {
-      user_id: 'string:36 pk',
-      email: 'string:100 unique notnull'
-    },
-    indexes: ['email']
-  });
-
-  const collected = collectIndexes(ir);
-  // Tidak boleh emit idx_users_email karena email sudah punya implicit index dari UNIQUE
-  assert.deepStrictEqual(collected, []);
-});
-
-test('create-index: skip-emit untuk kolom dengan pk shorthand karena PK sudah implicit indexed', () => {
-  const ir = defineModel('product', {
-    fields: {
-      product_id: 'string:36 pk'
-    },
-    indexes: ['product_id']
-  });
-
-  const collected = collectIndexes(ir);
-  assert.deepStrictEqual(collected, []);
-});
-
-test('create-index: skip-emit composite ketika UNIQUE composite dengan kolom set yang sama sudah ada', () => {
-  const ir = defineModel('invoice_line', {
-    fields: {
-      invoice_id: 'string:36',
-      product_id: 'string:36',
-      qty: 'integer'
-    },
-    primaryKey: ['invoice_id', 'product_id'],
-    uniques: [['invoice_id', 'product_id']],
-    indexes: [['invoice_id', 'product_id']]
-  });
-
-  const collected = collectIndexes(ir);
-  // Index composite dengan kolom set sama dengan UNIQUE composite harus skip
-  assert.strictEqual(collected.length, 0);
-});
-
-test('create-index: dedupe ketika auto-FK index dan user-declared index point ke kolom yang sama', () => {
-  const ir = defineModel('stock_inbound', {
-    fields: {
-      stock_inbound_id: 'string:36 pk',
-      warehouse_id: 'string:36 notnull'
-    },
-    indexes: ['warehouse_id'],
-    relations: {
-      warehouse: { type: 'belongsTo', localKey: 'warehouse_id', references: 'warehouse_id' }
-    }
-  });
-
-  const collected = collectIndexes(ir);
-  assert.strictEqual(collected.length, 1);
-  assert.deepStrictEqual(collected[0].columns, ['warehouse_id']);
-});
-
-test('create-index: identifier emit tanpa quote di MySQL', () => {
-  const ir = defineModel('orders', {
-    fields: {
-      order_id: 'string:36 pk',
-      status: 'string:20 notnull'
-    },
-    indexes: ['status']
-  });
-
-  const stmts = emitCreateIndexes(ir, mysql);
-  assert.deepStrictEqual(stmts, [
-    'CREATE INDEX idx_orders_status ON orders (status)'
-  ]);
-});
-
-// =====================================================
-// Phase 13: schema namespace support
-// =====================================================
-
-test('create-index: PG dengan schema → index name tetap unqualified, ON <schema>.<table> qualified', () => {
-  const ir = defineModel('products', {
-    schema: 'inventory',
-    fields: {
-      product_id: 'string:36 pk',
-      name: 'string:100 notnull'
-    },
-    indexes: ['name']
-  });
-  const stmts = emitCreateIndexes(ir, pg);
-  assert.deepStrictEqual(stmts, [
-    'CREATE INDEX idx_products_name ON inventory.products (name)'
-  ]);
-});
-
-test('create-index: SQLite + schema → throw error via formatTableIdentifier', () => {
-  const ir = defineModel('products', {
-    schema: 'inventory',
-    fields: {
-      product_id: 'string:36 pk',
-      name: 'string:100 notnull'
-    },
-    indexes: ['name']
-  });
-  assert.throws(
-    () => emitCreateIndexes(ir, sqlite),
-    /^Error: Table 'inventory\.products': SQLite does not support schema-qualified table names/
-  );
-});

package/generators/tests/unit/lib/dbschema-kit/emitters/create-table.test.js

@@ -1,376 +0,0 @@
-'use strict';
-
-const test = require('node:test');
-const assert = require('node:assert');
-
-const { defineModel } = require('../../../../../lib/dbschema-kit/define-model');
-const { getDialect } = require('../../../../../lib/dbschema-kit/dialect');
-const { emitCreateTable } = require('../../../../../lib/dbschema-kit/emitters/create-table');
-
-const pg = getDialect('postgres');
-const mysql = getDialect('mysql');
-const oracle = getDialect('oracle');
-const sqlite = getDialect('sqlite');
-
-test('create-table: tabel sederhana dengan single PK menghasilkan output sesuai snapshot', () => {
-  const ir = defineModel('category', {
-    fields: {
-      category_id: 'string:36 pk',
-      category_name: 'string:50 notnull'
-    }
-  });
-
-  const sql = emitCreateTable(ir, pg);
-  const expected = [
-    'CREATE TABLE category (',
-    '    category_id VARCHAR(36) NOT NULL,',
-    '    category_name VARCHAR(50) NOT NULL,',
-    '    CONSTRAINT pk_category PRIMARY KEY (category_id)',
-    ')'
-  ].join('\n');
-
-  assert.strictEqual(sql, expected);
-});
-
-test('create-table: tabel dengan composite PK emit PRIMARY KEY dengan multiple columns', () => {
-  const ir = defineModel('order_line', {
-    fields: {
-      order_id: 'string:36',
-      line_number: 'integer',
-      qty: 'integer notnull'
-    },
-    primaryKey: ['order_id', 'line_number']
-  });
-
-  const sql = emitCreateTable(ir, pg);
-  assert.match(sql, /CONSTRAINT pk_order_line PRIMARY KEY \(order_id, line_number\)/);
-});
-
-test('create-table: tabel dengan UNIQUE single column emit constraint UNIQUE per kolom', () => {
-  const ir = defineModel('users', {
-    fields: {
-      user_id: 'string:36 pk',
-      email: 'string:100 unique notnull'
-    }
-  });
-
-  const sql = emitCreateTable(ir, pg);
-  assert.match(sql, /CONSTRAINT uq_users_email UNIQUE \(email\)/);
-});
-
-test('create-table: tabel dengan UNIQUE composite emit composite UNIQUE constraint', () => {
-  const ir = defineModel('invoice_line', {
-    fields: {
-      invoice_id: 'string:36',
-      product_id: 'string:36',
-      qty: 'integer'
-    },
-    primaryKey: ['invoice_id', 'product_id'],
-    uniques: [['invoice_id', 'product_id']]
-  });
-
-  const sql = emitCreateTable(ir, pg);
-  assert.match(sql, /CONSTRAINT uq_invoice_line_invoice_id_product_id|CONSTRAINT uq_invoice_line_\S+ UNIQUE \(invoice_id, product_id\)/);
-});
-
-test('create-table: FK dengan onDelete setNull emit ON DELETE SET NULL', () => {
-  const ir = defineModel('stock_inbound', {
-    fields: {
-      stock_inbound_id: 'string:36 pk',
-      supplier_id: 'string:36'
-    },
-    relations: {
-      supplier: { type: 'belongsTo', localKey: 'supplier_id', references: 'supplier_id', onDelete: 'setNull' }
-    }
-  });
-
-  const sql = emitCreateTable(ir, pg);
-  assert.match(sql, /FOREIGN KEY \(supplier_id\) REFERENCES supplier \(supplier_id\) ON DELETE SET NULL/);
-});
-
-test('create-table: FK tanpa onDelete tidak emit ON DELETE clause', () => {
-  const ir = defineModel('stock_inbound', {
-    fields: {
-      stock_inbound_id: 'string:36 pk',
-      warehouse_id: 'string:36 notnull'
-    },
-    relations: {
-      warehouse: { type: 'belongsTo', localKey: 'warehouse_id', references: 'warehouse_id' }
-    }
-  });
-
-  const sql = emitCreateTable(ir, pg);
-  assert.match(sql, /FOREIGN KEY \(warehouse_id\) REFERENCES warehouse \(warehouse_id\)\s*$/m);
-  assert.doesNotMatch(sql, /ON DELETE/);
-});
-
-test('create-table: CHECK enum operator in emit IN clause dengan list values', () => {
-  const ir = defineModel('orders', {
-    fields: {
-      order_id: 'string:36 pk',
-      status: 'string:20 notnull'
-    },
-    checks: [
-      { field: 'status', in: ['draft', 'confirmed', 'closed'] }
-    ]
-  });
-
-  const sql = emitCreateTable(ir, pg);
-  assert.match(sql, /CONSTRAINT chk_orders_status CHECK \(status IN \('draft', 'confirmed', 'closed'\)\)/);
-});
-
-test('create-table: CHECK comparison gt dan gte emit operator SQL yang sesuai', () => {
-  const ir = defineModel('item', {
-    fields: {
-      item_id: 'string:36 pk',
-      qty: 'integer notnull',
-      price: 'decimal:15,2 notnull'
-    },
-    checks: [
-      { field: 'qty', gt: 0 },
-      { field: 'price', gte: 0 }
-    ]
-  });
-
-  const sql = emitCreateTable(ir, pg);
-  assert.match(sql, /CONSTRAINT chk_item_qty CHECK \(qty > 0\)/);
-  assert.match(sql, /CONSTRAINT chk_item_price CHECK \(price >= 0\)/);
-});
-
-test('create-table: field dengan autoUpdate emit kolom plain TIMESTAMP tanpa DEFAULT', () => {
-  const ir = defineModel('audit_log', {
-    fields: {
-      audit_id: 'string:36 pk',
-      updated_at: 'timestamp autoUpdate'
-    }
-  });
-
-  const sql = emitCreateTable(ir, pg);
-  assert.match(sql, /updated_at TIMESTAMP/);
-  assert.doesNotMatch(sql, /updated_at TIMESTAMP[^,\n]*DEFAULT/);
-});
-
-test('create-table: field dengan default now() emit DEFAULT CURRENT_TIMESTAMP di Postgres', () => {
-  const ir = defineModel('audit_log', {
-    fields: {
-      audit_id: 'string:36 pk',
-      created_at: 'timestamp notnull default:now()'
-    }
-  });
-
-  const sql = emitCreateTable(ir, pg);
-  assert.match(sql, /created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP/);
-});
-
-test('create-table: identifier emit tanpa quote di Postgres maupun MySQL', () => {
-  const ir = defineModel('user_account', {
-    fields: {
-      user_id: 'string:36 pk',
-      user_name: 'string:50 notnull'
-    }
-  });
-
-  const pgSql = emitCreateTable(ir, pg);
-  assert.match(pgSql, /CREATE TABLE user_account/);
-  assert.match(pgSql, /user_id VARCHAR\(36\)/);
-
-  const mysqlSql = emitCreateTable(ir, mysql);
-  assert.match(mysqlSql, /CREATE TABLE user_account/);
-  assert.match(mysqlSql, /user_id VARCHAR\(36\)/);
-});
-
-test('create-table: boolean default di MySQL menghasilkan literal string bukan boolean native', () => {
-  const ir = defineModel('feature_flag', {
-    fields: {
-      flag_id: 'string:36 pk',
-      is_enabled: 'boolean notnull default:true'
-    }
-  });
-
-  const pgSql = emitCreateTable(ir, pg);
-  assert.match(pgSql, /is_enabled BOOLEAN NOT NULL DEFAULT TRUE/);
-
-  const mysqlSql = emitCreateTable(ir, mysql);
-  assert.match(mysqlSql, /is_enabled VARCHAR\(5\) NOT NULL DEFAULT 'true'/);
-});
-
-test('create-table: dialect Oracle menggunakan VARCHAR2 untuk string dan NUMBER untuk integer', () => {
-  const ir = defineModel('product', {
-    fields: {
-      product_id: 'string:36 pk',
-      stock_qty: 'integer notnull'
-    }
-  });
-
-  const sql = emitCreateTable(ir, oracle);
-  assert.match(sql, /product_id VARCHAR2\(36\)/);
-  assert.match(sql, /stock_qty NUMBER\(10\)/);
-});
-
-test('create-table: dialect SQLite emit identifier tanpa quote dan VARCHAR(5) untuk boolean', () => {
-  const ir = defineModel('settings', {
-    fields: {
-      setting_id: 'string:36 pk',
-      enabled: 'boolean default:false'
-    }
-  });
-
-  const sql = emitCreateTable(ir, sqlite);
-  assert.match(sql, /setting_id VARCHAR\(36\)/);
-  assert.match(sql, /enabled VARCHAR\(5\) DEFAULT 'false'/);
-});
-
-test('create-table: order constraint adalah PK lalu UNIQUE single lalu UNIQUE composite lalu FK lalu CHECK', () => {
-  const ir = defineModel('inventory_lot', {
-    fields: {
-      lot_id: 'string:36 pk',
-      lot_code: 'string:50 unique notnull',
-      warehouse_id: 'string:36 notnull',
-      shelf_code: 'string:20 notnull',
-      status: 'string:20 notnull'
-    },
-    uniques: [['warehouse_id', 'shelf_code']],
-    relations: {
-      warehouse: { type: 'belongsTo', localKey: 'warehouse_id', references: 'warehouse_id', onDelete: 'restrict' }
-    },
-    checks: [
-      { field: 'status', in: ['available', 'reserved'] }
-    ]
-  });
-
-  const sql = emitCreateTable(ir, pg);
-  const pkPos = sql.indexOf('PRIMARY KEY');
-  const uqSinglePos = sql.indexOf('uq_inventory_lot_lot_code');
-  const uqCompositePos = sql.search(/UNIQUE \(warehouse_id, shelf_code\)/);
-  const fkPos = sql.indexOf('FOREIGN KEY');
-  const chkPos = sql.indexOf('CHECK');
-
-  assert.ok(pkPos > 0, 'PK harus ada');
-  assert.ok(uqSinglePos > pkPos, 'UNIQUE single harus setelah PK');
-  assert.ok(uqCompositePos > uqSinglePos, 'UNIQUE composite harus setelah UNIQUE single');
-  assert.ok(fkPos > uqCompositePos, 'FK harus setelah UNIQUE composite');
-  assert.ok(chkPos > fkPos, 'CHECK harus setelah FK');
-});
-
-test('create-table: CHECK pada field yang sama dengan op berbeda menambahkan suffix op', () => {
-  const ir = defineModel('item', {
-    fields: {
-      item_id: 'string:36 pk',
-      qty: 'integer notnull'
-    },
-    checks: [
-      { field: 'qty', gt: 0 },
-      { field: 'qty', lte: 1000 }
-    ]
-  });
-
-  const sql = emitCreateTable(ir, pg);
-  assert.match(sql, /CONSTRAINT chk_item_qty_gt CHECK \(qty > 0\)/);
-  assert.match(sql, /CONSTRAINT chk_item_qty_lte CHECK \(qty <= 1000\)/);
-});
-
-test('create-table: CHECK string value di-quote dengan single quote dan escape internal apostrophe', () => {
-  const ir = defineModel('country', {
-    fields: {
-      country_id: 'string:36 pk',
-      region: 'string:50 notnull'
-    },
-    checks: [
-      { field: 'region', eq: "O'Hara" }
-    ]
-  });
-
-  const sql = emitCreateTable(ir, pg);
-  assert.match(sql, /CHECK \(region = 'O''Hara'\)/);
-});
-
-test('create-table: closing paren di kolom 0 dan tidak ada trailing semicolon', () => {
-  const ir = defineModel('foo', {
-    fields: {
-      id: 'string:36 pk'
-    }
-  });
-
-  const sql = emitCreateTable(ir, pg);
-  assert.ok(sql.endsWith(')'), 'output diakhiri tanda kurung tutup');
-  assert.ok(!sql.endsWith(';'), 'tidak ada trailing semicolon');
-  const lines = sql.split('\n');
-  assert.strictEqual(lines[lines.length - 1], ')');
-});
-
-// =====================================================
-// Phase 13: schema namespace support
-// =====================================================
-
-test('create-table: PG dengan schema → CREATE TABLE <schema>.<table>', () => {
-  const ir = defineModel('products', {
-    schema: 'inventory',
-    fields: {
-      product_id: 'string:36 pk',
-      name: 'string:100 notnull'
-    }
-  });
-  const sql = emitCreateTable(ir, pg);
-  assert.match(sql, /^CREATE TABLE inventory\.products \(/);
-  assert.match(sql, /CONSTRAINT pk_products PRIMARY KEY \(product_id\)/, 'constraint name TIDAK ikut schema prefix');
-});
-
-test('create-table: PG tanpa schema → CREATE TABLE <table> (existing behavior)', () => {
-  const ir = defineModel('products', {
-    fields: {
-      product_id: 'string:36 pk',
-      name: 'string:100 notnull'
-    }
-  });
-  const sql = emitCreateTable(ir, pg);
-  assert.match(sql, /^CREATE TABLE products \(/);
-});
-
-test('create-table: MySQL dengan schema → CREATE TABLE <schema>.<table>', () => {
-  const ir = defineModel('products', {
-    schema: 'inventory',
-    fields: { product_id: 'string:36 pk', name: 'string:100 notnull' }
-  });
-  const sql = emitCreateTable(ir, mysql);
-  assert.match(sql, /^CREATE TABLE inventory\.products \(/);
-});
-
-test('create-table: Oracle dengan schema → CREATE TABLE <schema>.<table> (default emit prefix)', () => {
-  const ir = defineModel('products', {
-    schema: 'inventory',
-    fields: { product_id: 'string:36 pk', name: 'string:100 notnull' }
-  });
-  const sql = emitCreateTable(ir, oracle);
-  assert.match(sql, /^CREATE TABLE inventory\.products \(/);
-});
-
-test('create-table: SQLite + schema → throw error eksplisit', () => {
-  const ir = defineModel('products', {
-    schema: 'inventory',
-    fields: { product_id: 'string:36 pk', name: 'string:100 notnull' }
-  });
-  assert.throws(
-    () => emitCreateTable(ir, sqlite),
-    /^Error: Table 'inventory\.products': SQLite does not support schema-qualified table names/
-  );
-});
-
-test('create-table: FK target qualified emit REFERENCES <schema>.<table>', () => {
-  const ir = defineModel('products', {
-    schema: 'inventory',
-    fields: {
-      product_id: 'string:36 pk',
-      category_id: 'string:36'
-    },
-    relations: {
-      category: {
-        type: 'belongsTo',
-        target: 'inventory.categories',
-        localKey: 'category_id',
-        references: 'category_id'
-      }
-    }
-  });
-  const sql = emitCreateTable(ir, pg);
-  assert.match(sql, /REFERENCES inventory\.categories \(category_id\)/);
-});

package/generators/tests/unit/lib/dbschema-kit/emitters/drop-table.test.js

@@ -1,78 +0,0 @@
-'use strict';
-
-const test = require('node:test');
-const assert = require('node:assert');
-
-const { defineModel } = require('../../../../../lib/dbschema-kit/define-model');
-const { getDialect } = require('../../../../../lib/dbschema-kit/dialect');
-const { emitDropTable } = require('../../../../../lib/dbschema-kit/emitters/drop-table');
-
-function makeIr(tableName, schemaName) {
-  const opts = { fields: { id: 'string:36 pk' } };
-  if (schemaName) opts.schema = schemaName;
-  return defineModel(tableName, opts);
-}
-
-test('drop-table: PostgreSQL menghasilkan DROP TABLE IF EXISTS dengan CASCADE', () => {
-  const sql = emitDropTable(makeIr('stock_inbound'), getDialect('postgres'));
-  assert.strictEqual(sql, 'DROP TABLE IF EXISTS stock_inbound CASCADE');
-});
-
-test('drop-table: MySQL menghasilkan DROP TABLE IF EXISTS tanpa quote', () => {
-  const sql = emitDropTable(makeIr('stock_inbound'), getDialect('mysql'));
-  assert.strictEqual(sql, 'DROP TABLE IF EXISTS stock_inbound');
-});
-
-test('drop-table: SQLite menghasilkan DROP TABLE IF EXISTS tanpa CASCADE', () => {
-  const sql = emitDropTable(makeIr('stock_inbound'), getDialect('sqlite'));
-  assert.strictEqual(sql, 'DROP TABLE IF EXISTS stock_inbound');
-});
-
-test('drop-table: Oracle menghasilkan PL/SQL block dengan EXCEPTION handling untuk ORA-00942', () => {
-  const sql = emitDropTable(makeIr('stock_inbound'), getDialect('oracle'));
-  assert.match(sql, /BEGIN/);
-  assert.match(sql, /EXECUTE IMMEDIATE 'DROP TABLE stock_inbound CASCADE CONSTRAINTS'/);
-  assert.match(sql, /EXCEPTION/);
-  assert.match(sql, /WHEN OTHERS THEN/);
-  assert.match(sql, /SQLCODE != -942/);
-  assert.match(sql, /RAISE/);
-  assert.match(sql, /END;/);
-  assert.ok(sql.endsWith('/'), 'Oracle output diakhiri dengan terminator /');
-});
-
-test('drop-table: dialect tidak dikenal melempar error eksplisit', () => {
-  const fakeDialect = {
-    name: 'mssql',
-    formatTableIdentifier: (ir) => ir.tableName
-  };
-  assert.throws(
-    () => emitDropTable(makeIr('foo'), fakeDialect),
-    /Unsupported dialect: mssql/
-  );
-});
-
-// =====================================================
-// Phase 13: schema namespace support
-// =====================================================
-
-test('drop-table: PG dengan schema emit DROP TABLE IF EXISTS <schema>.<table> CASCADE', () => {
-  const sql = emitDropTable(makeIr('products', 'inventory'), getDialect('postgres'));
-  assert.strictEqual(sql, 'DROP TABLE IF EXISTS inventory.products CASCADE');
-});
-
-test('drop-table: MySQL dengan schema emit DROP TABLE IF EXISTS <schema>.<table>', () => {
-  const sql = emitDropTable(makeIr('products', 'inventory'), getDialect('mysql'));
-  assert.strictEqual(sql, 'DROP TABLE IF EXISTS inventory.products');
-});
-
-test('drop-table: Oracle dengan schema emit DROP TABLE <schema>.<table> CASCADE CONSTRAINTS', () => {
-  const sql = emitDropTable(makeIr('products', 'inventory'), getDialect('oracle'));
-  assert.match(sql, /EXECUTE IMMEDIATE 'DROP TABLE inventory\.products CASCADE CONSTRAINTS'/);
-});
-
-test('drop-table: SQLite + schema throw error eksplisit', () => {
-  assert.throws(
-    () => emitDropTable(makeIr('products', 'inventory'), getDialect('sqlite')),
-    /^Error: Table 'inventory\.products': SQLite does not support schema-qualified table names/
-  );
-});

package/generators/tests/unit/lib/dbschema-kit/fixtures/connection/invalid-dialect.env

@@ -1,6 +0,0 @@
-DB_TYPE=mssql
-DB_HOST=localhost
-DB_PORT=1433
-DB_NAME=test
-DB_USER=sa
-DB_PASSWORD=secret

package/generators/tests/unit/lib/dbschema-kit/fixtures/connection/missing-dialect.env

@@ -1,5 +0,0 @@
-DB_HOST=localhost
-DB_PORT=5432
-DB_NAME=mini_inventory
-DB_USER=postgres
-DB_PASSWORD=secret

package/generators/tests/unit/lib/dbschema-kit/fixtures/connection/missing-host.env

@@ -1,5 +0,0 @@
-DB_TYPE=postgresql
-DB_PORT=5432
-DB_NAME=mini_inventory
-DB_USER=postgres
-DB_PASSWORD=secret

package/generators/tests/unit/lib/dbschema-kit/fixtures/connection/oracle-valid.env

@@ -1,6 +0,0 @@
-DB_TYPE=oracle
-DB_HOST=localhost
-DB_PORT=1521
-DB_SERVICE_NAME=XEPDB1
-DB_USER=system
-DB_PASSWORD=secret

package/generators/tests/unit/lib/dbschema-kit/fixtures/connection/postgres-valid.env

@@ -1,7 +0,0 @@
-# PostgreSQL config sample
-DB_TYPE=postgresql
-DB_HOST=localhost
-DB_PORT=5432
-DB_NAME=mini_inventory
-DB_USER=postgres
-DB_PASSWORD=secret

package/generators/tests/unit/lib/dbschema-kit/fixtures/connection/sqlite-valid.env

@@ -1,2 +0,0 @@
-DB_TYPE=sqlite
-DB_FILE=./database.sqlite

package/generators/tests/unit/lib/dbschema-kit/fixtures/integration/mini-inventory/category.js

@@ -1,11 +0,0 @@
-'use strict';
-
-module.exports = ({ defineModel }) => defineModel('category', {
-  fields: {
-    category_id: 'uuid pk',
-    category_code: 'string:20 unique notnull',
-    category_name: 'string:100 notnull',
-    is_active: 'boolean default:true'
-  },
-  indexes: ['is_active']
-});

package/generators/tests/unit/lib/dbschema-kit/fixtures/integration/mini-inventory/item_product.js

@@ -1,11 +0,0 @@
-'use strict';
-
-module.exports = ({ defineModel }) => defineModel('item_product', {
-  fields: {
-    item_product_id: 'uuid pk',
-    product_code: 'string:20 unique notnull',
-    product_name: 'string:100 notnull',
-    category_id: 'uuid fk:category.category_id notnull',
-    is_active: 'boolean default:true'
-  }
-});