@carbonorm/carbonnode 3.7.6 → 3.7.8

package/scripts/generateRestBindings.cjs

@@ -89,7 +89,10 @@ var MySQLDump = /** @class */ (function () {
         var hexBlobOption = data ? '--hex-blob ' : '--no-data ';
         var createInfoOption = schemas ? '' : ' --no-create-info ';
         var cmd = "".concat(mysqldump, " --defaults-extra-file=\"").concat(defaultsExtraFile, "\" ").concat(otherOption, " --set-gtid-purged=\"OFF\" --skip-add-locks --lock-tables=false --single-transaction --quick ").concat(createInfoOption).concat(hexBlobOption).concat(this.DB_NAME, " ").concat(specificTable, " > '").concat(outputFile, "'");
-        this.executeAndCheckStatus(cmd);
+        this.executeAndCheckStatus(cmd, false);
+        if (!fs.existsSync(outputFile)) {
+            console.warn("[generateRestBindings] mysqldump output not found at ".concat(outputFile, ". If running in CI/no-DB environment, ensure a prebuilt dump file exists at this path."));
+        }
         return (this.mysqldump = outputFile);
     };
     MySQLDump.executeAndCheckStatus = function (command, exitOnFailure, output) {
@@ -112,9 +115,9 @@ var MySQLDump = /** @class */ (function () {
     MySQLDump.DB_PASS = argMap['--pass'] || 'password';
     MySQLDump.DB_HOST = argMap['--host'] || '127.0.0.1';
     MySQLDump.DB_PORT = argMap['--port'] || '3306';
-    MySQLDump.DB_NAME = argMap['--dbname'] || 'assessorly';
-    MySQLDump.DB_PREFIX = argMap['--prefix'] || 'carbon_';
-    MySQLDump.RELATIVE_OUTPUT_DIR = argMap['--output'] || '/src/api/rest';
+    MySQLDump.DB_NAME = argMap['--dbname'] || 'sakila';
+    MySQLDump.DB_PREFIX = argMap['--prefix'] || '';
+    MySQLDump.RELATIVE_OUTPUT_DIR = argMap['--output'] || '/src';
     MySQLDump.OUTPUT_DIR = path.join(process.cwd(), MySQLDump.RELATIVE_OUTPUT_DIR);
     return MySQLDump;
 }());
@@ -405,6 +408,14 @@ fs.writeFileSync(path.join(process.cwd(), 'C6MySqlDump.json'), JSON.stringify(ta
 // import this file  src/assets/handlebars/C6.tsx.handlebars for a mustache template
 var c6Template = fs.readFileSync(path.resolve(__dirname, 'assets/handlebars/C6.ts.handlebars'), 'utf-8');
 var c6TestTemplate = fs.readFileSync(path.resolve(__dirname, 'assets/handlebars/C6.test.ts.handlebars'), 'utf-8');
-fs.writeFileSync(path.join(MySQLDump.OUTPUT_DIR, 'C6.ts'), Handlebars.compile(c6Template)(tableData));
-fs.writeFileSync(path.join(MySQLDump.OUTPUT_DIR, 'C6.test.ts'), Handlebars.compile(c6TestTemplate)(tableData));
+var outputDir = MySQLDump.OUTPUT_DIR;
+fs.writeFileSync(path.join(outputDir, 'C6.ts'), Handlebars.compile(c6Template)(tableData));
+fs.writeFileSync(path.join(outputDir, 'C6.test.ts'), Handlebars.compile(c6TestTemplate)(tableData));
+// compile generated TypeScript for runtime tests
+try {
+    execSync("npx tsc ".concat(path.join(outputDir, 'C6.ts'), " --target ES2020 --module ES2020 --moduleResolution node --esModuleInterop --skipLibCheck --outDir ").concat(outputDir));
+}
+catch (e) {
+    console.warn('TypeScript compilation for generated C6.ts reported errors:', e);
+}
 console.log('Successfully created CarbonORM bindings!');

package/scripts/generateRestBindings.ts

@@ -24,9 +24,9 @@ class MySQLDump {
     static DB_PASS = argMap['--pass'] || 'password';
     static DB_HOST = argMap['--host'] || '127.0.0.1';
     static DB_PORT = argMap['--port'] || '3306';
-    static DB_NAME = argMap['--dbname'] || 'assessorly';
-    static DB_PREFIX = argMap['--prefix'] || 'carbon_';
-    static RELATIVE_OUTPUT_DIR = argMap['--output'] || '/src/api/rest';
+    static DB_NAME = argMap['--dbname'] || 'sakila';
+    static DB_PREFIX = argMap['--prefix'] || '';
+    static RELATIVE_OUTPUT_DIR = argMap['--output'] || '/src';
     static OUTPUT_DIR = path.join(process.cwd(), MySQLDump.RELATIVE_OUTPUT_DIR);
 
     static buildCNF(cnfFile: string = '') {
@@ -92,7 +92,11 @@ class MySQLDump {
 
         const cmd = `${mysqldump} --defaults-extra-file="${defaultsExtraFile}" ${otherOption} --set-gtid-purged="OFF" --skip-add-locks --lock-tables=false --single-transaction --quick ${createInfoOption}${hexBlobOption}${this.DB_NAME} ${specificTable} > '${outputFile}'`;
 
-        this.executeAndCheckStatus(cmd);
+        this.executeAndCheckStatus(cmd, false);
+
+        if (!fs.existsSync(outputFile)) {
+            console.warn(`[generateRestBindings] mysqldump output not found at ${outputFile}. If running in CI/no-DB environment, ensure a prebuilt dump file exists at this path.`);
+        }
 
         return (this.mysqldump = outputFile);
 
@@ -290,7 +294,8 @@ const parseSQLToTypeScript = (sql: string) => {
                             .split(/,(?=(?:[^']*'[^']*')*[^']*$)/) // split only top-level commas
                             .map(s => s.trim().replace(/^'(.*)'$/, '$1'))
                         : null;
-                    const type = fullType.replace(/\(.+?\)/, '').split(' ')[0].toLowerCase();                    const lengthMatch = fullType.match(/\(([^)]+)\)/);
+                    const type = fullType.replace(/\(.+?\)/, '').split(' ')[0].toLowerCase();
+                    const lengthMatch = fullType.match(/\(([^)]+)\)/);
                     const length = lengthMatch ? lengthMatch[1] : '';
 
                     const sridMatch = line.match(/SRID\s+(\d+)/i);
@@ -343,7 +348,7 @@ const parseSQLToTypeScript = (sql: string) => {
 
         }
 
-        let REACT_IMPORT: false|string = false, CARBON_REACT_INSTANCE : false|string = false;
+        let REACT_IMPORT: false | string = false, CARBON_REACT_INSTANCE: false | string = false;
 
         if (argMap['--react']) {
 
@@ -489,7 +494,16 @@ fs.writeFileSync(path.join(process.cwd(), 'C6MySqlDump.json'), JSON.stringify(ta
 const c6Template = fs.readFileSync(path.resolve(__dirname, 'assets/handlebars/C6.ts.handlebars'), 'utf-8');
 const c6TestTemplate = fs.readFileSync(path.resolve(__dirname, 'assets/handlebars/C6.test.ts.handlebars'), 'utf-8');
 
-fs.writeFileSync(path.join(MySQLDump.OUTPUT_DIR, 'C6.ts'), Handlebars.compile(c6Template)(tableData));
-fs.writeFileSync(path.join(MySQLDump.OUTPUT_DIR, 'C6.test.ts'), Handlebars.compile(c6TestTemplate)(tableData));
+const outputDir = MySQLDump.OUTPUT_DIR;
+
+fs.writeFileSync(path.join(outputDir, 'C6.ts'), Handlebars.compile(c6Template)(tableData));
+fs.writeFileSync(path.join(outputDir, 'C6.test.ts'), Handlebars.compile(c6TestTemplate)(tableData));
+
+// compile generated TypeScript for runtime tests
+try {
+    execSync(`npx tsc ${path.join(outputDir, 'C6.ts')} --target ES2020 --module ES2020 --moduleResolution node --esModuleInterop --skipLibCheck --outDir ${outputDir}`);
+} catch (e) {
+    console.warn('TypeScript compilation for generated C6.ts reported errors:', e);
+}
 
 console.log('Successfully created CarbonORM bindings!')

package/src/__tests__/fixtures/c6.fixture.ts

@@ -0,0 +1,74 @@
+import type { iRest, C6RestfulModel } from "../../api/types/ormInterfaces";
+
+// Minimal C6 table descriptor for tests
+function tableModel<T extends Record<string, any>>(name: string, columns: Record<string, keyof T>): C6RestfulModel<string, T, keyof T & string> {
+  const TYPE_VALIDATION: any = {};
+  const COLUMNS: any = {};
+  Object.entries(columns).forEach(([fq, short]) => {
+    COLUMNS[fq] = short;
+    TYPE_VALIDATION[fq] = {
+      MYSQL_TYPE: 'VARCHAR(255)',
+      MAX_LENGTH: '255',
+      AUTO_INCREMENT: false,
+      SKIP_COLUMN_IN_POST: false,
+    };
+  });
+
+  // Derive primary keys: any short column ending with '_id'
+  const pkShorts = Object.values(columns)
+    .map(v => String(v))
+    .filter(v => v.toLowerCase().endsWith('_id')) as any[];
+  const pkFull = Object.entries(columns)
+    .filter(([, short]) => String(short).toLowerCase().endsWith('_id'))
+    .map(([fq]) => fq as any);
+
+  return {
+    TABLE_NAME: name,
+    PRIMARY: pkFull,
+    PRIMARY_SHORT: pkShorts as any,
+    COLUMNS,
+    TYPE_VALIDATION,
+    REGEX_VALIDATION: {},
+    LIFECYCLE_HOOKS: { GET: {}, POST: {}, PUT: {}, DELETE: {} } as any,
+    TABLE_REFERENCES: {},
+    TABLE_REFERENCED_BY: {},
+    // Uppercase fields — not used by builders but required by type
+    ID: undefined as any,
+  } as any;
+}
+
+export function buildTestConfig() {
+  const actorCols = {
+    'actor.actor_id': 'actor_id',
+    'actor.first_name': 'first_name',
+    'actor.last_name': 'last_name',
+    'actor.binarycol': 'binarycol',
+  } as const;
+
+  const filmActorCols = {
+    'film_actor.actor_id': 'actor_id',
+    'film_actor.film_id': 'film_id',
+  } as const;
+
+  const C6 = {
+    C6VERSION: 'test',
+    TABLES: {
+      actor: tableModel<'actor' & any>('actor', actorCols as any),
+      film_actor: tableModel<'film_actor' & any>('film_actor', filmActorCols as any),
+    },
+    PREFIX: '',
+    ORM: {} as any,
+  } as any;
+
+  // Special-case: mark binary column as BINARY to test conversion
+  C6.TABLES.actor.TYPE_VALIDATION['actor.binarycol'].MYSQL_TYPE = 'BINARY(16)';
+
+  const baseConfig: iRest<any, any, any> = {
+    C6,
+    restModel: C6.TABLES.actor,
+    requestMethod: 'GET',
+    verbose: false,
+  } as any;
+
+  return baseConfig;
+}

package/src/__tests__/normalizeSingularRequest.test.ts

@@ -0,0 +1,105 @@
+import { describe, it, expect } from 'vitest';
+import { normalizeSingularRequest } from '../api/utils/normalizeSingularRequest';
+import { C6C } from '../api/C6Constants';
+import type { C6RestfulModel } from '../api/types/ormInterfaces';
+
+function makeModel(table: string, pkShorts: string[], extraCols: string[] = []): C6RestfulModel<any, any, any> {
+  const COLUMNS: Record<string, string> = {};
+  const TYPE_VALIDATION: Record<string, any> = {};
+
+  // Always include PK columns as fully-qualified
+  for (const short of pkShorts) {
+    const fq = `${table}.${short}`;
+    COLUMNS[fq] = short;
+    TYPE_VALIDATION[fq] = { MYSQL_TYPE: 'INT', MAX_LENGTH: '11', AUTO_INCREMENT: false, SKIP_COLUMN_IN_POST: false };
+  }
+  // add extra simple columns
+  for (const short of extraCols) {
+    const fq = `${table}.${short}`;
+    COLUMNS[fq] = short;
+    TYPE_VALIDATION[fq] = { MYSQL_TYPE: 'VARCHAR(255)', MAX_LENGTH: '255', AUTO_INCREMENT: false, SKIP_COLUMN_IN_POST: false };
+  }
+
+  return {
+    TABLE_NAME: table,
+    PRIMARY: pkShorts.map(s => `${table}.${s}`) as any,
+    PRIMARY_SHORT: pkShorts as any,
+    COLUMNS: COLUMNS as any,
+    TYPE_VALIDATION,
+    REGEX_VALIDATION: {},
+    LIFECYCLE_HOOKS: { GET: {}, POST: {}, PUT: {}, DELETE: {} } as any,
+    TABLE_REFERENCES: {},
+    TABLE_REFERENCED_BY: {},
+  } as any;
+}
+
+describe('normalizeSingularRequest', () => {
+  it('converts GET singular T into WHERE by PK', () => {
+    const model = makeModel('actor', ['actor_id'], ['first_name']);
+    const req = { actor_id: 5 } as any;
+    const out = normalizeSingularRequest('GET', req, model);
+    expect(out).toHaveProperty(C6C.WHERE);
+    expect((out as any)[C6C.WHERE]).toEqual({ actor_id: 5 });
+  });
+
+  it('converts DELETE singular T into DELETE:true and WHERE by PK', () => {
+    const model = makeModel('actor', ['actor_id']);
+    const req = { actor_id: 7 } as any;
+    const out = normalizeSingularRequest('DELETE', req, model);
+    expect((out as any)[C6C.DELETE]).toBe(true);
+    expect((out as any)[C6C.WHERE]).toEqual({ actor_id: 7 });
+  });
+
+  it('converts PUT singular T into UPDATE (non-PK fields) and WHERE by PK', () => {
+    const model = makeModel('actor', ['actor_id'], ['first_name']);
+    const req = { actor_id: 9, first_name: 'NEW' } as any;
+    const out = normalizeSingularRequest('PUT', req, model);
+    expect((out as any)[C6C.WHERE]).toEqual({ actor_id: 9 });
+    expect((out as any)[C6C.UPDATE]).toEqual({ first_name: 'NEW' });
+  });
+
+  it('PUT singular T throws if no updatable fields beyond PK are present', () => {
+    const model = makeModel('actor', ['actor_id']);
+    const req = { actor_id: 3 } as any;
+    expect(() => normalizeSingularRequest('PUT', req, model)).toThrow(/must include at least one non-primary field to update/);
+  });
+
+  it('GET without PKs leaves request untouched (collection query)', () => {
+    const model = makeModel('actor', ['actor_id'], ['first_name']);
+    const req = { first_name: 'A' } as any;
+    const out = normalizeSingularRequest('GET', req, model) as any;
+    expect(out).toBe(req);
+    expect(out.first_name).toBe('A');
+  });
+
+  it('supports composite primary keys and requires all PKs', () => {
+    const model = makeModel('link', ['from_id', 'to_id']);
+    const ok = { from_id: 1, to_id: 2 } as any;
+    const out = normalizeSingularRequest('GET', ok, model);
+    expect((out as any)[C6C.WHERE]).toEqual({ from_id: 1, to_id: 2 });
+
+    const missing = { from_id: 1 } as any;
+    expect(() => normalizeSingularRequest('DELETE', missing, model)).toThrow(/Missing: \[to_id\]/);
+  });
+
+  it('GET with table that has no primary key leaves request untouched', () => {
+    const model = makeModel('nopk', [], ['name']);
+    const req = { name: 'X' } as any;
+    const out = normalizeSingularRequest('GET', req, model);
+    expect(out).toBe(req);
+  });
+
+  it('leaves already complex requests untouched', () => {
+    const model = makeModel('actor', ['actor_id']);
+    const complex = { [C6C.WHERE]: { actor_id: 1 }, [C6C.PAGINATION]: { LIMIT: 1 } } as any;
+    const out = normalizeSingularRequest('GET', complex, model);
+    expect(out).toBe(complex);
+  });
+
+  it('GET with only PAGINATION passes through unchanged', () => {
+    const model = makeModel('actor', ['actor_id']);
+    const req = { [C6C.PAGINATION]: { [C6C.PAGE]: 1, [C6C.LIMIT]: 100 } } as any;
+    const out = normalizeSingularRequest('GET', req, model);
+    expect(out).toBe(req);
+  });
+});