@restforgejs/platform 5.0.1 → 5.0.8

package/generators/lib/utils/database-introspector.js

@@ -17,11 +17,12 @@ const path = require('path');
 let pg = null;
 let mysql2 = null;
 let oracledb = null;
+let betterSqlite3 = null;
 
 /**
  * Lazy-load database driver berdasarkan DB_TYPE.
  *
- * @param {string} dbType - 'postgresql' | 'mysql' | 'oracle'
+ * @param {string} dbType - 'postgresql' | 'mysql' | 'oracle' | 'sqlite'
  * @returns {Object} Driver module
  */
 function loadDriver(dbType) {
@@ -47,11 +48,48 @@ function loadDriver(dbType) {
         }
       }
       return oracledb;
+    case 'sqlite':
+      if (!betterSqlite3) {
+        try { betterSqlite3 = require('better-sqlite3'); } catch (e) {
+          throw new Error('SQLite driver (better-sqlite3) not installed. Run: npm install better-sqlite3');
+        }
+      }
+      return betterSqlite3;
     default:
-      throw new Error(`Unsupported DB_TYPE: ${dbType}. Supported: postgresql, mysql, oracle`);
+      throw new Error(`Unsupported DB_TYPE: ${dbType}. Supported: postgresql, mysql, oracle, sqlite`);
   }
 }
 
+/**
+ * Ekstrak nama kolom yang membawa penanda boolean `<col> IN ('true','false')`
+ * dari teks CHECK constraint / DDL. Dipakai introspeksi untuk mengenali kembali
+ * kolom VARCHAR sebagai boolean pada dialect non-native (mysql/oracle/sqlite),
+ * penanda yang di-emit otomatis oleh dbschema-kit create-table/alter-table.
+ *
+ * Toleran terhadap variasi quoting identifier ("col" / `col` / [col]),
+ * urutan nilai ('true','false' atau 'false','true'), serta charset introducer
+ * MySQL (mis. _utf8mb4'true'). Nama kolom dikembalikan lowercase.
+ *
+ * @param {string} text - Teks CHECK clause atau CREATE TABLE DDL
+ * @returns {string[]} Daftar nama kolom boolean (lowercase)
+ */
+function extractBooleanCheckColumns(text) {
+  const cols = [];
+  if (!text || typeof text !== 'string') return cols;
+  // `\\?` mentoleransi backslash-escaped quote yang dikembalikan MySQL pada
+  // CHECK_CLAUSE (mis. _utf8mb4\'true\'); SQLite/Oracle memakai 'true' polos.
+  const re = /["`\[]?([A-Za-z_][A-Za-z0-9_]*)["`\]]?\s+IN\s*\(\s*(?:_\w+)?\\?'(true|false)\\?'\s*,\s*(?:_\w+)?\\?'(true|false)\\?'\s*\)/gi;
+  let m;
+  while ((m = re.exec(text)) !== null) {
+    const a = m[2].toLowerCase();
+    const b = m[3].toLowerCase();
+    if ((a === 'true' && b === 'false') || (a === 'false' && b === 'true')) {
+      cols.push(m[1].toLowerCase());
+    }
+  }
+  return cols;
+}
+
 // PostgreSQL FK action codes -> human-readable
 const PG_FK_ACTION = {
   a: 'NO ACTION',
@@ -142,12 +180,21 @@ class DatabaseIntrospector {
         this.dbType = 'mysql';
       } else if (dbTypeRaw === 'oracle' || dbTypeRaw === 'oracledb') {
         this.dbType = 'oracle';
+      } else if (dbTypeRaw === 'sqlite' || dbTypeRaw === 'sqlite3') {
+        this.dbType = 'sqlite';
       } else {
         this.dbType = dbTypeRaw;
       }
 
-      // Validate required keys
-      const requiredKeys = ['DB_HOST', 'DB_PORT', 'DB_USER', 'DB_PASSWORD', 'DB_NAME'];
+      // Validate required keys.
+      //
+      // SQLite adalah file-based: tidak ada host/port/user/password. Yang wajib
+      // hanya path ke file database, diterima via DB_FILE (konsisten dengan
+      // dbschema-kit connection.js) atau DB_NAME sebagai fallback. Server-based
+      // dialect (postgresql/mysql/oracle) tetap mewajibkan kredensial koneksi.
+      const requiredKeys = this.dbType === 'sqlite'
+        ? [] // dicek terpisah di bawah karena boleh DB_FILE ATAU DB_NAME
+        : ['DB_HOST', 'DB_PORT', 'DB_USER', 'DB_PASSWORD', 'DB_NAME'];
       const missingKeys = requiredKeys.filter(key => !config[key]);
 
       if (missingKeys.length > 0) {
@@ -155,9 +202,19 @@ class DatabaseIntrospector {
         return false;
       }
 
+      if (this.dbType === 'sqlite' && !config.DB_FILE && !config.DB_NAME) {
+        console.error('Error: Missing required config key for SQLite: DB_FILE (atau DB_NAME) berisi path file database');
+        return false;
+      }
+
       this.config = config;
       if (!this.quiet) {
-        console.log(`Config loaded: [${this.dbType}] ${config.DB_NAME}@${config.DB_HOST}:${config.DB_PORT}`);
+        if (this.dbType === 'sqlite') {
+          // SQLite file-based: host:port tidak relevan, tampilkan path file saja.
+          console.log(`Config loaded: [sqlite] ${config.DB_FILE || config.DB_NAME}`);
+        } else {
+          console.log(`Config loaded: [${this.dbType}] ${config.DB_NAME}@${config.DB_HOST}:${config.DB_PORT}`);
+        }
       }
       return true;
     } catch (error) {
@@ -227,6 +284,19 @@ class DatabaseIntrospector {
           break;
         }
 
+        case 'sqlite': {
+          // better-sqlite3 bersifat synchronous: konstruktor langsung membuka
+          // file. Mode readonly + fileMustExist dipakai karena introspeksi
+          // bersifat read-only dan men-generate payload dari DB yang sudah ada;
+          // tanpa fileMustExist, file yang salah path akan dibuat kosong dan
+          // berujung error "table not found" yang membingungkan.
+          const Database = driver;
+          const filePath = this.config.DB_FILE || this.config.DB_NAME;
+          this.pool = new Database(filePath, { readonly: true, fileMustExist: true });
+          this.pool.prepare('SELECT 1').get();
+          break;
+        }
+
         default:
           throw new Error(`Unsupported DB_TYPE: ${this.dbType}`);
       }
@@ -252,6 +322,9 @@ class DatabaseIntrospector {
     try {
       if (this.dbType === 'oracle') {
         await this.pool.close(0);
+      } else if (this.dbType === 'sqlite') {
+        // better-sqlite3 Database.close() synchronous, tidak punya .end()
+        this.pool.close();
       } else {
         await this.pool.end();
       }
@@ -304,6 +377,13 @@ class DatabaseIntrospector {
           await conn.close();
         }
       }
+      case 'sqlite': {
+        // better-sqlite3 synchronous. Placeholder positional '?' kompatibel
+        // dengan SQL/PRAGMA table-valued function (mis. pragma_table_info(?)).
+        // .all() valid untuk statement yang mengembalikan row (SELECT/PRAGMA).
+        const stmt = this.pool.prepare(sql);
+        return stmt.all(...(params || []));
+      }
       default:
         return [];
     }
@@ -325,6 +405,9 @@ class DatabaseIntrospector {
       case 'postgresql': return { schema: 'public', table: tableName };
       case 'mysql': return { schema: this.config.DB_NAME, table: tableName };
       case 'oracle': return { schema: this.config.DB_USER.toUpperCase(), table: tableName };
+      // SQLite tidak mengenal schema (hanya database 'main'); schema diabaikan
+      // di seluruh query introspeksi sqlite (memakai sqlite_master / PRAGMA).
+      case 'sqlite': return { schema: 'main', table: tableName };
       default: return { schema: 'public', table: tableName };
     }
   }
@@ -361,7 +444,10 @@ class DatabaseIntrospector {
              ORDER BY ordinal_position LIMIT 1`,
             [schema, table]
           );
-          return rows.length > 0 ? rows[0].column_name : null;
+          // MySQL 8 information_schema mengembalikan key UPPERCASE (COLUMN_NAME).
+          // Tanpa fallback ini PK tidak terdeteksi -> payload jatuh ke tebakan
+          // nama PK yang salah (konsisten dengan pola getColumns mysql).
+          return rows.length > 0 ? (rows[0].column_name || rows[0].COLUMN_NAME) : null;
         }
 
         case 'oracle': {
@@ -375,6 +461,17 @@ class DatabaseIntrospector {
           );
           return rows.length > 0 ? rows[0].column_name.toLowerCase() : null;
         }
+
+        case 'sqlite': {
+          // pragma_table_info.pk = 0 (bukan PK) atau urutan kolom dalam PK
+          // composite (1-based). Ambil kolom pertama (pk=1) konsisten dengan
+          // dialect lain yang mengembalikan satu kolom PK.
+          const rows = await this.query(
+            `SELECT name FROM pragma_table_info(?) WHERE pk > 0 ORDER BY pk`,
+            [table]
+          );
+          return rows.length > 0 ? rows[0].name : null;
+        }
       }
       return null;
     } catch (error) {
@@ -422,6 +519,16 @@ class DatabaseIntrospector {
           );
           return rows.length > 0;
         }
+
+        case 'sqlite': {
+          const rows = await this.query(
+            `SELECT 1 FROM sqlite_master
+             WHERE type IN ('table', 'view') AND name = ?
+             LIMIT 1`,
+            [table]
+          );
+          return rows.length > 0;
+        }
       }
       return false;
     } catch (error) {
@@ -471,6 +578,14 @@ class DatabaseIntrospector {
           );
           return rows.map(r => r.column_name.toLowerCase());
         }
+
+        case 'sqlite': {
+          const rows = await this.query(
+            `SELECT name FROM pragma_table_info(?) ORDER BY cid`,
+            [table]
+          );
+          return rows.map(r => r.name);
+        }
       }
       return [];
     } catch (error) {
@@ -528,6 +643,18 @@ class DatabaseIntrospector {
           rows.forEach(r => { types[r.column_name.toLowerCase()] = r.data_type.toLowerCase(); });
           break;
         }
+
+        case 'sqlite': {
+          const rows = await this.query(
+            `SELECT name, type FROM pragma_table_info(?) ORDER BY cid`,
+            [table]
+          );
+          // Declared type direfleksikan apa adanya (lowercased). generateDateTimeFields
+          // mencocokkan terhadap 'date'/'timestamp'/'time'/'datetime'; tipe DDL sqlite
+          // RESTForge memakai DATE/TIMESTAMP sehingga match deterministik.
+          rows.forEach(r => { types[r.name] = (r.type || '').toLowerCase(); });
+          break;
+        }
       }
 
       return types;
@@ -616,6 +743,53 @@ class DatabaseIntrospector {
             };
           });
         }
+
+        case 'sqlite': {
+          // Alias kolom "notnull" ke `nn`: NOTNULL adalah keyword SQLite sehingga
+          // alias unquoted `AS notnull` memicu syntax error.
+          const rows = await this.query(
+            `SELECT name, type, "notnull" AS nn, dflt_value, pk
+             FROM pragma_table_info(?) ORDER BY cid`,
+            [table]
+          );
+          // Normalisasi declared type sqlite -> format PostgreSQL-like agar
+          // generateFieldValidation (yang mencocokkan terhadap data_type seperti
+          // 'varchar'/'integer'/'decimal'/'date'/'timestamp') berperilaku identik
+          // lintas dialect. Tipe DDL sqlite RESTForge: VARCHAR(n), TEXT, INTEGER,
+          // BIGINT, DECIMAL(p,s), DATE, TIMESTAMP (boolean & uuid -> VARCHAR).
+          const STRING_BASES = ['varchar', 'character varying', 'char', 'character', 'nvarchar', 'nchar', 'text', 'clob'];
+          return rows.map(r => {
+            const declared = (r.type || '').trim().toLowerCase();
+            const paren = declared.match(/^([a-z0-9_ ]+?)\s*\(([^)]*)\)\s*$/);
+            const base = paren ? paren[1].trim() : declared;
+            const argParts = paren && paren[2].trim() !== ''
+              ? paren[2].split(',').map(s => parseInt(s.trim(), 10)).filter(n => !Number.isNaN(n))
+              : [];
+
+            let charMaxLen = null;
+            let numericPrecision = null;
+            let numericScale = null;
+            if (argParts.length > 0) {
+              if (STRING_BASES.includes(base)) {
+                charMaxLen = argParts[0];
+              } else {
+                numericPrecision = argParts[0];
+                numericScale = argParts.length > 1 ? argParts[1] : 0;
+              }
+            }
+
+            return {
+              column_name: r.name,
+              data_type: base,
+              udt_name: base,
+              column_default: r.dflt_value !== undefined && r.dflt_value !== null ? String(r.dflt_value) : null,
+              is_nullable: Number(r.nn) === 1 ? 'NO' : 'YES',
+              character_maximum_length: charMaxLen,
+              numeric_precision: numericPrecision,
+              numeric_scale: numericScale
+            };
+          });
+        }
       }
       return [];
     } catch (error) {
@@ -662,6 +836,14 @@ class DatabaseIntrospector {
           );
           return rows.map(r => r.column_name.toLowerCase());
         }
+
+        case 'sqlite': {
+          const rows = await this.query(
+            `SELECT name FROM pragma_table_info(?) WHERE "notnull" = 1`,
+            [table]
+          );
+          return rows.map(r => r.name);
+        }
       }
       return [];
     } catch (error) {
@@ -746,6 +928,45 @@ class DatabaseIntrospector {
           }
           return result;
         }
+
+        case 'sqlite': {
+          const result = [];
+
+          // PRIMARY KEY: dari pragma_table_info. Menangani INTEGER PRIMARY KEY
+          // (rowid alias) yang TIDAK muncul di pragma_index_list. Composite PK
+          // diurutkan berdasarkan kolom pk (1-based).
+          const pkRows = await this.query(
+            `SELECT name, pk FROM pragma_table_info(?) WHERE pk > 0 ORDER BY pk`,
+            [table]
+          );
+          if (pkRows.length > 0) {
+            result.push({
+              name: `pk_${table}`,
+              type: 'PRIMARY KEY',
+              columns: pkRows.map(r => r.name)
+            });
+          }
+
+          // UNIQUE: pragma_index_list origin = 'u' (UNIQUE constraint), bukan
+          // 'pk' (primary key, sudah ditangani) atau 'c' (CREATE INDEX manual).
+          const uniqueIdx = await this.query(
+            `SELECT name FROM pragma_index_list(?) WHERE origin = 'u'`,
+            [table]
+          );
+          for (const idx of uniqueIdx) {
+            const cols = await this.query(
+              `SELECT name FROM pragma_index_info(?) ORDER BY seqno`,
+              [idx.name]
+            );
+            result.push({
+              name: idx.name,
+              type: 'UNIQUE',
+              columns: cols.map(c => c.name)
+            });
+          }
+
+          return result;
+        }
       }
       return [];
     } catch (error) {
@@ -754,6 +975,78 @@ class DatabaseIntrospector {
     }
   }
 
+  /**
+   * Deteksi kolom boolean pada dialect varchar (mysql/oracle/sqlite) lewat
+   * penanda CHECK `<col> IN ('true','false')` yang di-emit dbschema-kit.
+   *
+   * PostgreSQL memakai tipe BOOLEAN native sehingga sudah terdeteksi di
+   * getDetailedColumnInfo (data_type 'boolean'); method ini mengembalikan []
+   * untuk postgresql. Degradasi anggun: bila katalog CHECK tidak tersedia
+   * (mis. MySQL < 8.0.16 atau Oracle < 12c tanpa search_condition_vc), error
+   * di-catch dan dikembalikan [] (kolom tetap diperlakukan string).
+   *
+   * @param {string} tableName - Nama table
+   * @returns {Promise<string[]>} Nama kolom boolean (lowercase)
+   */
+  async getBooleanColumns(tableName) {
+    if (!this.pool) return [];
+
+    try {
+      const { schema, table } = this.parseTableName(tableName);
+      let texts = [];
+
+      switch (this.dbType) {
+        case 'sqlite': {
+          const rows = await this.query(
+            `SELECT sql FROM sqlite_master WHERE type = 'table' AND name = ?`,
+            [table]
+          );
+          texts = rows.map(r => r.sql || '');
+          break;
+        }
+
+        case 'mysql': {
+          const rows = await this.query(
+            `SELECT cc.CHECK_CLAUSE AS clause
+             FROM information_schema.CHECK_CONSTRAINTS cc
+             JOIN information_schema.TABLE_CONSTRAINTS tc
+               ON cc.CONSTRAINT_NAME = tc.CONSTRAINT_NAME
+              AND cc.CONSTRAINT_SCHEMA = tc.CONSTRAINT_SCHEMA
+             WHERE tc.TABLE_SCHEMA = ? AND tc.TABLE_NAME = ? AND tc.CONSTRAINT_TYPE = 'CHECK'`,
+            [schema, table]
+          );
+          texts = rows.map(r => r.CHECK_CLAUSE || r.clause || '');
+          break;
+        }
+
+        case 'oracle': {
+          // search_condition_vc (VARCHAR2) tersedia Oracle 12c+; lebih mudah
+          // di-query daripada kolom LONG search_condition.
+          const rows = await this.query(
+            `SELECT search_condition_vc AS clause FROM user_constraints
+             WHERE table_name = :1 AND constraint_type = 'C'`,
+            [table.toUpperCase()]
+          );
+          texts = rows.map(r => r.clause || r.search_condition_vc || '');
+          break;
+        }
+
+        default:
+          // postgresql: boolean native, tidak perlu penanda
+          return [];
+      }
+
+      const cols = new Set();
+      for (const t of texts) {
+        for (const c of extractBooleanCheckColumns(t)) cols.add(c);
+      }
+      return Array.from(cols);
+    } catch (error) {
+      console.warn(`  Warning: Could not detect boolean columns: ${error.message}`);
+      return [];
+    }
+  }
+
   /**
    * List all tables (and views) in database.
    *
@@ -909,6 +1202,25 @@ class DatabaseIntrospector {
           break;
         }
 
+        case 'sqlite': {
+          // SQLite tidak punya schema; schemaFilter diabaikan. Tabel internal
+          // (sqlite_*, mis. sqlite_sequence) di-skip kecuali includeSystem.
+          // Legacy mode: BASE TABLE saja; modern mode: table + view.
+          const typeList = modernMode ? "('table', 'view')" : "('table')";
+          let sql = `SELECT name, type FROM sqlite_master WHERE type IN ${typeList}`;
+          if (!includeSystem) {
+            sql += " AND name NOT LIKE 'sqlite_%'";
+          }
+          sql += ' ORDER BY name';
+          const rows = await this.query(sql, []);
+          rawRows = rows.map(r => ({
+            schema: 'main',
+            name: r.name,
+            type: r.type === 'view' ? 'view' : 'table'
+          }));
+          break;
+        }
+
         default:
           return [];
       }
@@ -1073,6 +1385,39 @@ class DatabaseIntrospector {
           }
           return Object.values(grouped);
         }
+
+        case 'sqlite': {
+          // pragma_foreign_key_list: kolom id (group FK composite), seq (urutan
+          // kolom), table (tabel referensi), from/to (kolom lokal/referensi),
+          // on_update/on_delete. SQLite tidak menamai FK constraint, jadi nama
+          // disintesis fk_<table>_<id>. references.schema null (tanpa schema).
+          const rows = await this.query(
+            `SELECT id, seq, "table" AS ref_table, "from" AS col, "to" AS ref_col,
+                    on_update, on_delete
+             FROM pragma_foreign_key_list(?) ORDER BY id, seq`,
+            [table]
+          );
+          const grouped = {};
+          for (const r of rows) {
+            const id = r.id;
+            if (!grouped[id]) {
+              grouped[id] = {
+                name: `fk_${table}_${id}`,
+                columns: [],
+                references: {
+                  schema: null,
+                  table: r.ref_table,
+                  columns: []
+                },
+                onDelete: r.on_delete || null,
+                onUpdate: r.on_update || null
+              };
+            }
+            grouped[id].columns.push(r.col);
+            grouped[id].references.columns.push(r.ref_col);
+          }
+          return Object.values(grouped);
+        }
       }
       return [];
     } catch (error) {
@@ -1178,6 +1523,30 @@ class DatabaseIntrospector {
           }
           return Object.values(grouped);
         }
+
+        case 'sqlite': {
+          // pragma_index_list: name, unique (0/1), origin ('pk'|'u'|'c').
+          // INTEGER PRIMARY KEY (rowid) tidak punya index terpisah sehingga
+          // tidak muncul di sini, konsisten dengan realita storage sqlite.
+          const idxRows = await this.query(
+            `SELECT name, "unique" AS is_unique, origin FROM pragma_index_list(?) ORDER BY name`,
+            [table]
+          );
+          const result = [];
+          for (const idx of idxRows) {
+            const cols = await this.query(
+              `SELECT name FROM pragma_index_info(?) ORDER BY seqno`,
+              [idx.name]
+            );
+            result.push({
+              name: idx.name,
+              columns: cols.map(c => c.name),
+              unique: Number(idx.is_unique) === 1,
+              primary: idx.origin === 'pk'
+            });
+          }
+          return result;
+        }
       }
       return [];
     } catch (error) {
@@ -1249,6 +1618,12 @@ class DatabaseIntrospector {
           const rows = await this.query(sql, []);
           return rows.map(r => String(r.username).toLowerCase());
         }
+
+        case 'sqlite': {
+          // SQLite tidak mengenal konsep schema bernama (hanya database 'main'
+          // dan optional 'temp'/attached). Tidak ada user schema untuk diiterasi.
+          return [];
+        }
       }
       return [];
     } catch (error) {
@@ -1336,6 +1711,25 @@ class DatabaseIntrospector {
         }
       }
 
+      case 'sqlite': {
+        // prepare() me-resolve metadata kolom tanpa mengeksekusi baris.
+        // stmt.columns() mengembalikan deskriptor kolom untuk statement
+        // yang mengembalikan data (SELECT).
+        try {
+          const stmt = this.pool.prepare(trimmed);
+          const columns = (stmt.columns() || []).map(c => String(c.name).toLowerCase());
+          return { ok: true, columns };
+        } catch (err) {
+          return {
+            ok: false,
+            error: {
+              code: err.code || 'unknown',
+              message: err.message
+            }
+          };
+        }
+      }
+
       default:
         throw new Error(`Unsupported DB_TYPE: ${this.dbType}`);
     }
@@ -1398,6 +1792,23 @@ class DatabaseIntrospector {
         }
       }
 
+      case 'sqlite': {
+        // prepare() melakukan validasi sintaks + resolusi schema tanpa
+        // mengeksekusi statement, ekuivalen dengan peran EXPLAIN di dialect lain.
+        try {
+          this.pool.prepare(sql);
+          return { ok: true };
+        } catch (err) {
+          return {
+            ok: false,
+            error: {
+              code: err.code || 'unknown',
+              message: err.message
+            }
+          };
+        }
+      }
+
       default:
         throw new Error(`Unsupported DB_TYPE: ${this.dbType}`);
     }

package/generators/lib/validators/argument-validator.js

@@ -330,7 +330,7 @@ class ArgumentValidator {
      }
  
      const trimmed = databaseType.trim().toLowerCase();
-     const validTypes = ['postgres', 'oracle', 'mysql'];
+     const validTypes = ['postgres', 'oracle', 'mysql', 'sqlite'];
  
      if (!validTypes.includes(trimmed)) {
        throw new Error(`Database type '${databaseType}' is invalid. Valid options: ${validTypes.join(', ')}`);
@@ -436,7 +436,7 @@ class ArgumentValidator {
    --endpoint=<name>     Endpoint name to create (OPTIONAL)
    --payload=<file>      Payload file name without .json (OPTIONAL)
 
-   --database=<type>     Database type: postgres|oracle|mysql (DEFAULT: postgres)
+   --database=<type>     Database type: postgres|oracle|mysql|sqlite (DEFAULT: postgres)
    --force=<bool>        Overwrite existing files (skip confirmation): true|false (DEFAULT: false)
    --create-examples=<bool>  Create example files for testing: true|false (DEFAULT: true)
    --skip-sql-validation=<bool>  Skip SQL keywords validation: true|false (DEFAULT: false)

package/integrity-manifest.json

@@ -1,27 +1,27 @@
 {
-  "version": "5.0.1",
-  "generated": "2026-05-31T03:19:51.440Z",
+  "version": "5.0.8",
+  "generated": "2026-06-01T03:35:49.528Z",
   "generator": "restforge-build-system",
   "algorithm": "sha256",
   "files": {
-    "server.js": "2a00acf82b46545d92744aa738d6e0f5c18e589a8cbf39f82cbce56cda172a1a",
-    "src/utils/license-client.js": "cb3485ce1b80693679e1befb1e3d1a05c52b2be9364b2fda6cf9605ed24257a4",
-    "src/utils/trusted-keys.js": "c99a0521c5fb97326f928452265d77f4d4c9d05b0761a2b267315c8bbc416d80",
-    "cli/consumer.js": "7fcee1e3c4b441e4730f3e2908bcaf832cd80c47140385951a6d2e7d0752a07d",
-    "src/utils/security-checks.js": "dd5b60c2410339b0d1501ff2a31f32373568256a9b3510477927e2f4018c3adf",
-    "scripts/verify-integrity.js": "e90f1ff83445a0c31fa27dbe883e3911c7fd8365627fb314d51ca391fa2ad695",
+    "server.js": "c2dad04d38ab4ab2b287276c84f58b30e26c9c0a5c257f6273ffb820b68c2cf2",
+    "src/utils/license-client.js": "ac2ce8875b21009f826d0afddcdae32e5307b123a05fe1b62eec0569843e9472",
+    "src/utils/trusted-keys.js": "01a7f3eb841fe8b4062bdc4a10899686d78af7580e10bba23f037021bf9bf905",
+    "cli/consumer.js": "a82465404d9da7aca1c0ae0caf820934b9e73d564225e2054d409fa5450fe2db",
+    "src/utils/security-checks.js": "e599e1b4c01ef857b5e99bee9d5aec9bd5e326262d04a1272c3a088cdcc9eceb",
+    "scripts/verify-integrity.js": "8fd989b49b31c776071b2eeba02831cbf1511d9ee05a906548acf0f6c3909da5",
     "bin/restforge-hwinfo-linux": "d9a0071b0acf58a020e738a29837de356f531a5a84d363a2adc50563e3874b8f",
     "bin/restforge-hwinfo-darwin": "d35b15d4e6d7bbdd8317490335ba9602ce5c218519898fa3eabe18cc9c5bb1b6",
     "bin/restforge-hwinfo.exe": "351fa4d33459d30de804ee78deb5eb977b77b688fe1b7b461cdaa214a82f145e",
-    "generators/lib/templates/mysql-template.js": "393be6e36bbb0d7a90ea674985512156b4c7bd18a09cb0e0b488c82893cb5d31",
-    "generators/lib/templates/oracle-template.js": "5899cbf1b5b6b38ec5c2fb23f677650a10c6700597a879214959aa8fad6567f4",
-    "generators/lib/templates/postgres-template.js": "c862c0cba61720da1222657fa95fe18ffe6cc3e59e32022c9652389c6e51342e",
-    "generators/lib/templates/sqlite-template.js": "33e597b3120bcc862d891a8c23a02dfaa8e31e512c56f24aaeb37c105dc43945",
-    "generators/lib/templates/dashboard-catalog.js": "2eef46fb442bcd3325fd56758d22acdf88be8b1221e8b99a6b53804b91f10618",
-    "generators/lib/templates/dbschema-catalog.js": "70d65baeb0211a29ce824b24a4b27b66b83d07785afb85f90ba8964be0b3cac2",
-    "generators/lib/templates/field-validation-catalog.js": "de743c44c141e287df8a6fe9cca6bf3040de35dd744ecc9d5106c711e264a4b4",
-    "generators/lib/templates/query-declarative-catalog.js": "e571ca7ae08944ff11bbbcfaa75c1558cdfa6be6fa8d2f919795dbe118a42db3",
-    "generators/lib/templates/db-connection-env.js": "fbd9dc6caa4771f9e4ea4cfbee53f7d6e63937ba9fabad39da5e22ab55933467"
+    "generators/lib/templates/mysql-template.js": "cef2a73006f4981d2bc008c704e552b61f27cfb0150dc4c1c905d1a7819d7039",
+    "generators/lib/templates/oracle-template.js": "57a38d80aced2d735d033bd05a52df89d6238a47d1a0a84c8a4c2250746ff593",
+    "generators/lib/templates/postgres-template.js": "0f6bc325e5b41a11e7ce9766e58a020f2cd5b85b88b282778d059d81bf7aa601",
+    "generators/lib/templates/sqlite-template.js": "ef3658fb92047abc52c5acf2869ceca4298a3e22fdaf549c7daa806f6ec73aa9",
+    "generators/lib/templates/dashboard-catalog.js": "5ad9b475aa7ccd5c097abe4ecf2777a9036714dceb2984e74bf321adb2bdde98",
+    "generators/lib/templates/dbschema-catalog.js": "9e45b2219352f321fbb2b5f0a2ea14dc7e689d85ee6ab9c94c66275bda697b81",
+    "generators/lib/templates/field-validation-catalog.js": "5d77379d8f069204fdbe2d8700932fc76583cbf2431946413aca72b3dcfe1c93",
+    "generators/lib/templates/query-declarative-catalog.js": "d12158465f017aa41ee0eac6699a4a79321fdbb63ea984821e403f0d155e27ba",
+    "generators/lib/templates/db-connection-env.js": "3fb59cfdd6badd39543e3725bc163c6672c6f7dd78c69bf126b9b1bf8e5d54c5"
   },
   "stats": {
     "totalFiles": 18,
@@ -31,7 +31,7 @@
   "signature": {
     "algorithm": "ed25519",
     "keyId": "rfs-manifest-2026-05",
-    "value": "1467eb2cf73a93bd5e2f28f4f9f3c5e4baf15215ea058bd5fee5da859608233b454208dcc472200d07a9cd347494f3fc9e6ad676234bc74feb1f9bdbdf5eaa05",
+    "value": "17b3022758981192df691f2b55aeed699e81dd0106ed15eeb445fefdc8392cd4ff7e5e1ab29725dc6592d2156545d0535e115059a5eba5cf8dd9464d710fa80e",
     "scope": "canonical-json(manifest-without-signature)"
   }
 }