langaro-api 1.0.6 → 1.0.8

package/lib/cli/init.js

@@ -395,7 +395,23 @@ class App {
 
     if (process.env.NODE_ENV !== 'test') {
       this.express.use(morgan('dev', {
-        skip: (req) => req.method === 'OPTIONS',
+        skip: (req) => {
+          // Ignore OPTIONS requests
+          if (req.method === 'OPTIONS') {
+            return true;
+          }
+
+          const skipUrls = [
+            process.env.BULLBOARD_PATH,
+            \`\${process.env.BULLBOARD_PATH}/static\`,
+          ];
+
+          if (skipUrls.indexOf(req.baseUrl) !== -1) {
+            return true;
+          }
+
+          return false;
+        },
       }));
     }
 

package/lib/generators/controllers.js

@@ -1,6 +1,7 @@
 const fs = require('fs');
 const path = require('path');
-const { pascalCase, extractMethods } = require('../utils');
+const { pascalCase, extractMethodsWithLocations } = require('../utils');
+const { generateSourceMap } = require('../sourcemap');
 
 function scanControllerEntries(controllersDir) {
   const entries = [];
@@ -22,42 +23,102 @@ function scanControllerEntries(controllersDir) {
   return entries.sort((a, b) => a.tableName.localeCompare(b.tableName));
 }
 
-function generateControllersDts(controllersDir) {
+function resolveServiceFile(tableName, servicesDir, modelsDir) {
+  if (servicesDir) {
+    const serviceFile = path.join(servicesDir, `${tableName}.services.js`);
+    if (fs.existsSync(serviceFile)) return serviceFile;
+  }
+  if (modelsDir) {
+    const modelFile = path.join(modelsDir, `${tableName}.model.js`);
+    if (fs.existsSync(modelFile)) return modelFile;
+  }
+  return null;
+}
+
+function generateControllersDts(controllersDir, outputDir, servicesDir, modelsDir) {
   const lines = ['// Auto-generated by langaro-api — DO NOT EDIT', ''];
   const controllerEntries = scanControllerEntries(controllersDir);
+  const mappings = [];
+  const sources = [];
+  const sourceIndexMap = {};
+
+  function getSourceIndex(filePath) {
+    const rel = path.relative(outputDir, filePath).replace(/\\/g, '/');
+    if (!(rel in sourceIndexMap)) {
+      sourceIndexMap[rel] = sources.length;
+      sources.push(rel);
+    }
+    return sourceIndexMap[rel];
+  }
+
+  function addMapping(col, sourceIdx, srcLine, srcCol) {
+    mappings.push({
+      genLine: lines.length,
+      genCol: col,
+      sourceIndex: sourceIdx,
+      sourceLine: srcLine,
+      sourceCol: srcCol,
+    });
+  }
 
   // Base classes for JSDoc @param on "ServicesClass"
-  controllerEntries.forEach(({ tableName }) => {
+  controllerEntries.forEach(({ tableName, filePath }) => {
     const pc = pascalCase(tableName);
-    lines.push(
-      `declare class ${pc}ControllerBase {`,
-      `  service: ServicesMap['${pc}Services'];`,
-      '  services: ServicesMap;',
-      '  Queue: QueueMap;',
-      '  io: any;',
-      '}',
-      '',
-    );
+    const controllerIdx = getSourceIndex(filePath);
+    const serviceFile = resolveServiceFile(tableName, servicesDir, modelsDir);
+    const serviceIdx = serviceFile ? getSourceIndex(serviceFile) : controllerIdx;
+
+    addMapping(0, controllerIdx, 0, 0);
+    lines.push(`declare class ${pc}ControllerBase {`);
+
+    // service: property → maps to the service/model file
+    addMapping(0, serviceIdx, 0, 0);
+    lines.push(`  service: ServicesMap['${pc}Services'];`);
+
+    // remaining properties → map to controller file
+    addMapping(0, controllerIdx, 0, 0);
+    lines.push('  services: ServicesMap;');
+    addMapping(0, controllerIdx, 0, 0);
+    lines.push('  Queue: QueueMap;');
+    addMapping(0, controllerIdx, 0, 0);
+    lines.push('  io: any;');
+    addMapping(0, controllerIdx, 0, 0);
+    lines.push('}');
+    lines.push('');
   });
 
   // Controller interfaces with their methods (for router autocomplete)
   controllerEntries.forEach(({ tableName, filePath }) => {
     const pc = pascalCase(tableName);
-    const methods = extractMethods(filePath);
+    const methods = extractMethodsWithLocations(filePath);
+    const sourceIdx = getSourceIndex(filePath);
+
+    addMapping(0, sourceIdx, 0, 0);
     lines.push(`declare interface I${pc}Controller extends ${pc}ControllerBase {`);
-    methods.forEach((m) => lines.push(`  ${m}(...args: any[]): any;`));
-    lines.push('}', '');
+    methods.forEach((m) => {
+      addMapping(2, sourceIdx, m.line, m.col);
+      lines.push(`  ${m.name}(...args: any[]): any;`);
+    });
+    addMapping(0, sourceIdx, 0, 0);
+    lines.push('}');
+    lines.push('');
   });
 
-  // ControllersMap — used to type the "controllers" param in routers
+  // ControllersMap
   lines.push('declare interface ControllersMap {');
-  controllerEntries.forEach(({ tableName }) => {
+  controllerEntries.forEach(({ tableName, filePath }) => {
     const pc = pascalCase(tableName);
+    addMapping(2, getSourceIndex(filePath), 0, 0);
     lines.push(`  ${pc}Controller: I${pc}Controller;`);
   });
   lines.push('}', '');
 
-  return lines.join('\n');
+  lines.push('//# sourceMappingURL=controllers.d.ts.map');
+
+  const content = lines.join('\n');
+  const sourceMap = generateSourceMap('controllers.d.ts', sources, mappings);
+
+  return { content, sourceMap };
 }
 
 module.exports = { scanControllerEntries, generateControllersDts };

package/lib/generators/crud.js

@@ -1,69 +1,159 @@
-module.exports = function generateCrudDts() {
-  return [
+const path = require('path');
+const { extractMethodsWithLocations } = require('../utils');
+const { generateSourceMap } = require('../sourcemap');
+
+// Extract method name from a .d.ts declaration line like "  getWhere(...): ..."
+function extractMethodName(line) {
+  const match = line.match(/^\s+([a-zA-Z_$][a-zA-Z0-9_$]*)\s*\(/);
+  return match ? match[1] : null;
+}
+
+module.exports = function generateCrudDts(projectRoot, outputDir) {
+  // Try to resolve knex-extended-crud source
+  let crudSourcePath = null;
+  let methodLineMap = {};
+
+  if (projectRoot && outputDir) {
+    try {
+      crudSourcePath = require.resolve('knex-extended-crud', {
+        paths: [projectRoot],
+      });
+      const methods = extractMethodsWithLocations(crudSourcePath);
+      methods.forEach((m) => {
+        methodLineMap[m.name] = { line: m.line, col: m.col };
+      });
+    } catch {
+      crudSourcePath = null;
+    }
+  }
+
+  const hasMappings = !!crudSourcePath;
+  const mappings = [];
+  const sources = [];
+  let sourceIdx = -1;
+
+  if (hasMappings) {
+    const rel = path.relative(outputDir, crudSourcePath).replace(/\\/g, '/');
+    sources.push(rel);
+    sourceIdx = 0;
+  }
+
+  function addMethodMapping(linesArr, methodName) {
+    if (!hasMappings) return;
+    const loc = methodLineMap[methodName];
+    if (loc) {
+      mappings.push({
+        genLine: linesArr.length,
+        genCol: 2,
+        sourceIndex: sourceIdx,
+        sourceLine: loc.line,
+        sourceCol: loc.col,
+      });
+    }
+  }
+
+  const lines = [
     '// Auto-generated by langaro-api — DO NOT EDIT',
     '',
-    'declare class CRUD {',
-    '  table: string;',
-    '  knex: any;',
-    '  hide: string[];',
-    '  append: string[];',
-    '  fields: Record<string, any>;',
-    '  schema: any;',
-    '  options: {',
-    '    perPage: number;',
-    '    currentPage: number;',
-    '    isLengthAware: boolean;',
-    '    exactMatch: boolean;',
-    '    sortBy: string;',
-    '    sort: string;',
-    '  };',
-    '',
-    '  createTransaction(): Promise<any>;',
-    '',
-    '  create(data?: Record<string, any>, transaction?: any): Promise<{ success: boolean; data: any }>;',
-    '  batchCreate(data?: any[], transaction?: any): Promise<{ success: boolean; data: any[] }>;',
-    '',
-    '  get(options?: CRUDGetOptions, transaction?: any): Promise<{ success: boolean; data: any[]; pagination?: any }>;',
-    '  getWhere(prop: string, value: any, options?: CRUDGetOptions, transaction?: any): Promise<{ success: boolean; data: any }>;',
-    '  search(field: string, term: string, options?: CRUDGetOptions, transaction?: any): Promise<{ success: boolean; data: any[] }>;',
-    '  count(options?: CRUDGetOptions, transaction?: any): Promise<number>;',
-    '',
-    '  updateWhere(',
-    '    prop: string, value: any, data?: Record<string, any>,',
-    '    options?: CRUDUpdateOptions, transaction?: any',
-    '  ): Promise<{ success: boolean; data: any }>;',
-    '  batchUpdate(data: any[], options?: CRUDBatchUpdateOptions, transaction?: any): Promise<any[]>;',
-    '',
-    '  deleteWhere(',
-    '    prop: string, values: any, options?: CRUDDeleteOptions, transaction?: any',
-    '  ): Promise<{ success: boolean; data: any }>;',
-    '',
-    '  defaultInsertValidations(',
-    '    requestData: Record<string, any>, options?: Record<string, any>, transaction?: any',
-    '  ): Promise<Record<string, any>>;',
-    '  defaultUpdateValidations(',
-    '    itemId: any, requestData: Record<string, any>,',
-    '    options?: Record<string, any>, transaction?: any',
-    '  ): Promise<Record<string, any>>;',
-    '  validateAndFormatFields(',
-    '    data: Record<string, any>, skipFields?: string[], transaction?: any',
-    '  ): Promise<{ success: boolean; data?: Record<string, any>; err?: string }>;',
-    '  validateForeignIds(data: Record<string, any>, transaction?: any): Promise<void>;',
-    '',
-    '  tableInfo(options?: Record<string, any>, transaction?: any): Promise<Record<string, any>>;',
-    '  requiredFields(options?: Record<string, any>, transaction?: any): Promise<{ data: string[] }>;',
-    '',
-    '  appendItems(',
-    '    items: any[], appendArr: string[], appendOptions?: Record<string, any>, transaction?: any',
-    '  ): Promise<any[]>;',
-    '  refreshCache(transaction?: any): Promise<void>;',
-    '  clearSchemaCache(): void;',
-    '  clearTableCache(tableName: string): void;',
-    '  disableCache(): void;',
-    '  enableCache(): void;',
-    '  setCacheTimeout(timeout: number): void;',
-    '}',
-    '',
+  ];
+
+  // CRUD class
+  lines.push('declare class CRUD {');
+  lines.push('  table: string;');
+  lines.push('  knex: any;');
+  lines.push('  hide: string[];');
+  lines.push('  append: string[];');
+  lines.push('  fields: Record<string, any>;');
+  lines.push('  schema: any;');
+  lines.push('  options: {');
+  lines.push('    perPage: number;');
+  lines.push('    currentPage: number;');
+  lines.push('    isLengthAware: boolean;');
+  lines.push('    exactMatch: boolean;');
+  lines.push('    sortBy: string;');
+  lines.push('    sort: string;');
+  lines.push('  };');
+  lines.push('');
+
+  addMethodMapping(lines, 'createTransaction');
+  lines.push('  createTransaction(): Promise<any>;');
+  lines.push('');
+
+  addMethodMapping(lines, 'create');
+  lines.push('  create(data?: Record<string, any>, transaction?: any): Promise<{ success: boolean; data: any }>;');
+  addMethodMapping(lines, 'batchCreate');
+  lines.push('  batchCreate(data?: any[], transaction?: any): Promise<{ success: boolean; data: any[] }>;');
+  lines.push('');
+
+  addMethodMapping(lines, 'get');
+  lines.push('  get(options?: CRUDGetOptions, transaction?: any): Promise<{ success: boolean; data: any[]; pagination?: any }>;');
+  addMethodMapping(lines, 'getWhere');
+  lines.push('  getWhere(prop: string, value: any, options?: CRUDGetOptions, transaction?: any): Promise<{ success: boolean; data: any }>;');
+  addMethodMapping(lines, 'search');
+  lines.push('  search(field: string, term: string, options?: CRUDGetOptions, transaction?: any): Promise<{ success: boolean; data: any[] }>;');
+  addMethodMapping(lines, 'count');
+  lines.push('  count(options?: CRUDGetOptions, transaction?: any): Promise<number>;');
+  lines.push('');
+
+  addMethodMapping(lines, 'updateWhere');
+  lines.push('  updateWhere(');
+  lines.push('    prop: string, value: any, data?: Record<string, any>,');
+  lines.push('    options?: CRUDUpdateOptions, transaction?: any');
+  lines.push('  ): Promise<{ success: boolean; data: any }>;');
+  addMethodMapping(lines, 'batchUpdate');
+  lines.push('  batchUpdate(data: any[], options?: CRUDBatchUpdateOptions, transaction?: any): Promise<any[]>;');
+  lines.push('');
+
+  addMethodMapping(lines, 'deleteWhere');
+  lines.push('  deleteWhere(');
+  lines.push('    prop: string, values: any, options?: CRUDDeleteOptions, transaction?: any');
+  lines.push('  ): Promise<{ success: boolean; data: any }>;');
+  lines.push('');
+
+  addMethodMapping(lines, 'defaultInsertValidations');
+  lines.push('  defaultInsertValidations(');
+  lines.push('    requestData: Record<string, any>, options?: Record<string, any>, transaction?: any');
+  lines.push('  ): Promise<Record<string, any>>;');
+  addMethodMapping(lines, 'defaultUpdateValidations');
+  lines.push('  defaultUpdateValidations(');
+  lines.push('    itemId: any, requestData: Record<string, any>,');
+  lines.push('    options?: Record<string, any>, transaction?: any');
+  lines.push('  ): Promise<Record<string, any>>;');
+  addMethodMapping(lines, 'validateAndFormatFields');
+  lines.push('  validateAndFormatFields(');
+  lines.push('    data: Record<string, any>, skipFields?: string[], transaction?: any');
+  lines.push('  ): Promise<{ success: boolean; data?: Record<string, any>; err?: string }>;');
+  addMethodMapping(lines, 'validateForeignIds');
+  lines.push('  validateForeignIds(data: Record<string, any>, transaction?: any): Promise<void>;');
+  lines.push('');
+
+  addMethodMapping(lines, 'tableInfo');
+  lines.push('  tableInfo(options?: Record<string, any>, transaction?: any): Promise<Record<string, any>>;');
+  addMethodMapping(lines, 'requiredFields');
+  lines.push('  requiredFields(options?: Record<string, any>, transaction?: any): Promise<{ data: string[] }>;');
+  lines.push('');
+
+  addMethodMapping(lines, 'appendItems');
+  lines.push('  appendItems(');
+  lines.push('    items: any[], appendArr: string[], appendOptions?: Record<string, any>, transaction?: any');
+  lines.push('  ): Promise<any[]>;');
+  addMethodMapping(lines, 'refreshCache');
+  lines.push('  refreshCache(transaction?: any): Promise<void>;');
+  addMethodMapping(lines, 'clearSchemaCache');
+  lines.push('  clearSchemaCache(): void;');
+  addMethodMapping(lines, 'clearTableCache');
+  lines.push('  clearTableCache(tableName: string): void;');
+  addMethodMapping(lines, 'disableCache');
+  lines.push('  disableCache(): void;');
+  addMethodMapping(lines, 'enableCache');
+  lines.push('  enableCache(): void;');
+  addMethodMapping(lines, 'setCacheTimeout');
+  lines.push('  setCacheTimeout(timeout: number): void;');
+  lines.push('}');
+  lines.push('');
+
+  // Options interfaces (no source mappings needed)
+  lines.push(
     'declare interface CRUDGetOptions {',
     '  perPage?: number;',
     '  currentPage?: number;',
@@ -153,5 +243,16 @@ module.exports = function generateCrudDts() {
     '  };',
     '}',
     '',
-  ].join('\n');
+  );
+
+  if (hasMappings) {
+    lines.push('//# sourceMappingURL=crud.d.ts.map');
+  }
+
+  const content = lines.join('\n');
+  const sourceMap = hasMappings
+    ? generateSourceMap('crud.d.ts', sources, mappings)
+    : null;
+
+  return { content, sourceMap };
 };

package/lib/generators/services.js

@@ -1,10 +1,23 @@
 const fs = require('fs');
 const path = require('path');
-const { pascalCase, extractMethods, isCustomService } = require('../utils');
+const { pascalCase, extractMethodsWithLocations, isCustomService } = require('../utils');
+const { generateSourceMap } = require('../sourcemap');
 
-module.exports = function generateServicesDts(servicesDir, modelsDir) {
+module.exports = function generateServicesDts(servicesDir, modelsDir, outputDir) {
   const lines = ['// Auto-generated by langaro-api — DO NOT EDIT', ''];
   const serviceEntries = [];
+  const mappings = [];
+  const sources = [];
+  const sourceIndexMap = {};
+
+  function getSourceIndex(filePath) {
+    const rel = path.relative(outputDir, filePath).replace(/\\/g, '/');
+    if (!(rel in sourceIndexMap)) {
+      sourceIndexMap[rel] = sources.length;
+      sources.push(rel);
+    }
+    return sourceIndexMap[rel];
+  }
 
   // Services with custom .services.js files
   if (fs.existsSync(servicesDir)) {
@@ -17,22 +30,42 @@ module.exports = function generateServicesDts(servicesDir, modelsDir) {
         const interfaceName = `I${serviceName}`;
         const filePath = path.join(servicesDir, file);
         const custom = isCustomService(filePath);
-        const methods = extractMethods(filePath);
+        const methods = extractMethodsWithLocations(filePath);
+        const sourceIdx = getSourceIndex(filePath);
+
+        const addMapping = (col, srcLine, srcCol) => {
+          mappings.push({
+            genLine: lines.length,
+            genCol: col,
+            sourceIndex: sourceIdx,
+            sourceLine: srcLine,
+            sourceCol: srcCol,
+          });
+        };
 
         if (custom) {
+          addMapping(0, 0, 0);
           lines.push(`declare interface ${interfaceName} {`);
+          addMapping(0, 0, 0);
           lines.push('  table: string;');
         } else {
+          addMapping(0, 0, 0);
           lines.push(`declare interface ${interfaceName} extends CRUD {`);
         }
-        methods.forEach((m) => lines.push(`  ${m}(...args: any[]): any;`));
-        lines.push('}', '');
+        methods.forEach((m) => {
+          addMapping(2, m.line, m.col);
+          lines.push(`  ${m.name}(...args: any[]): any;`);
+        });
+        addMapping(0, 0, 0);
+        lines.push('}');
+        lines.push('');
 
         serviceEntries.push({
           interfaceName,
           serviceName,
           tableName,
           custom,
+          sourceIdx,
         });
       });
   }
@@ -60,12 +93,22 @@ module.exports = function generateServicesDts(servicesDir, modelsDir) {
   lines.push('declare interface ServicesMap {');
   serviceEntries
     .sort((a, b) => a.serviceName.localeCompare(b.serviceName))
-    .forEach(({ interfaceName, serviceName }) => {
+    .forEach(({ interfaceName, serviceName, sourceIdx }) => {
+      const genLine = lines.length;
       lines.push(`  ${serviceName}: ${interfaceName};`);
+      if (sourceIdx !== undefined) {
+        mappings.push({
+          genLine,
+          genCol: 2,
+          sourceIndex: sourceIdx,
+          sourceLine: 0,
+          sourceCol: 0,
+        });
+      }
     });
   lines.push('}', '');
 
-  // ModelsConstructorMap — typed table names for "new models.xxx()"
+  // ModelsConstructorMap
   lines.push('declare interface ModelsConstructorMap {');
   serviceEntries
     .filter(({ custom }) => !custom)
@@ -77,10 +120,26 @@ module.exports = function generateServicesDts(servicesDir, modelsDir) {
   lines.push('}', '');
 
   // Base classes for JSDoc @param on the "model" parameter
-  serviceEntries.forEach(({ serviceName, custom }) => {
-    if (!custom) lines.push(`declare class ${serviceName}Base extends CRUD {}`);
+  serviceEntries.forEach(({ serviceName, custom, sourceIdx }) => {
+    if (!custom) {
+      if (sourceIdx !== undefined) {
+        mappings.push({
+          genLine: lines.length,
+          genCol: 0,
+          sourceIndex: sourceIdx,
+          sourceLine: 0,
+          sourceCol: 0,
+        });
+      }
+      lines.push(`declare class ${serviceName}Base extends CRUD {}`);
+    }
   });
   lines.push('');
 
-  return lines.join('\n');
+  lines.push('//# sourceMappingURL=services.d.ts.map');
+
+  const content = lines.join('\n');
+  const sourceMap = generateSourceMap('services.d.ts', sources, mappings);
+
+  return { content, sourceMap };
 };

package/lib/index.js

@@ -44,9 +44,21 @@ function generateTypes(userConfig = {}) {
 
   // Generate .d.ts files
   fs.mkdirSync(outputDir, { recursive: true });
-  fs.writeFileSync(path.join(outputDir, 'crud.d.ts'), generateCrudDts());
-  fs.writeFileSync(path.join(outputDir, 'services.d.ts'), generateServicesDts(servicesDir, modelsDir));
-  fs.writeFileSync(path.join(outputDir, 'controllers.d.ts'), generateControllersDts(controllersDir));
+
+  const crud = generateCrudDts(root, outputDir);
+  fs.writeFileSync(path.join(outputDir, 'crud.d.ts'), crud.content);
+  if (crud.sourceMap) {
+    fs.writeFileSync(path.join(outputDir, 'crud.d.ts.map'), crud.sourceMap);
+  }
+
+  const services = generateServicesDts(servicesDir, modelsDir, outputDir);
+  fs.writeFileSync(path.join(outputDir, 'services.d.ts'), services.content);
+  fs.writeFileSync(path.join(outputDir, 'services.d.ts.map'), services.sourceMap);
+
+  const controllers = generateControllersDts(controllersDir, outputDir, servicesDir, modelsDir);
+  fs.writeFileSync(path.join(outputDir, 'controllers.d.ts'), controllers.content);
+  fs.writeFileSync(path.join(outputDir, 'controllers.d.ts.map'), controllers.sourceMap);
+
   fs.writeFileSync(path.join(outputDir, 'index.d.ts'), generateIndexDts());
 
   // Inject JSDoc annotations into source files

package/lib/sourcemap.js

@@ -0,0 +1,67 @@
+const BASE64 = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
+
+function encodeVLQ(value) {
+  let vlq = value < 0 ? (-value << 1) + 1 : value << 1;
+  let encoded = '';
+  do {
+    let digit = vlq & 0x1f;
+    vlq >>>= 5;
+    if (vlq > 0) digit |= 0x20;
+    encoded += BASE64[digit];
+  } while (vlq > 0);
+  return encoded;
+}
+
+/**
+ * Generate a source map JSON string.
+ *
+ * @param {string} generatedFile - The name of the generated .d.ts file
+ * @param {string[]} sources - Array of relative source file paths
+ * @param {Array<{genLine: number, genCol: number, sourceIndex: number, sourceLine: number, sourceCol: number}>} mappings
+ * @returns {string} JSON source map
+ */
+function generateSourceMap(generatedFile, sources, mappings) {
+  const sorted = [...mappings].sort((a, b) => a.genLine - b.genLine || a.genCol - b.genCol);
+
+  let prevGenLine = 0;
+  let prevSourceIndex = 0;
+  let prevSourceLine = 0;
+  let prevSourceCol = 0;
+
+  const lineSegments = [];
+
+  sorted.forEach((m) => {
+    // Fill empty lines with ;
+    while (prevGenLine < m.genLine) {
+      lineSegments.push('');
+      prevGenLine++;
+    }
+
+    const segment =
+      encodeVLQ(m.genCol) +
+      encodeVLQ(m.sourceIndex - prevSourceIndex) +
+      encodeVLQ(m.sourceLine - prevSourceLine) +
+      encodeVLQ(m.sourceCol - prevSourceCol);
+
+    // Append to current line
+    if (lineSegments.length === 0 || prevGenLine > lineSegments.length - 1) {
+      lineSegments.push(segment);
+    } else {
+      const existing = lineSegments[lineSegments.length - 1];
+      lineSegments[lineSegments.length - 1] = existing ? existing + ',' + segment : segment;
+    }
+
+    prevSourceIndex = m.sourceIndex;
+    prevSourceLine = m.sourceLine;
+    prevSourceCol = m.sourceCol;
+  });
+
+  return JSON.stringify({
+    version: 3,
+    file: generatedFile,
+    sources,
+    mappings: lineSegments.join(';'),
+  });
+}
+
+module.exports = { generateSourceMap };

package/lib/utils.js

@@ -26,6 +26,10 @@ function matchAll(regex, text) {
 }
 
 function extractMethods(filePath) {
+  return extractMethodsWithLocations(filePath).map((m) => m.name);
+}
+
+function extractMethodsWithLocations(filePath) {
   const content = fs.readFileSync(filePath, 'utf8');
 
   const patterns = [
@@ -34,10 +38,23 @@ function extractMethods(filePath) {
     /^async\s+function\s+([a-zA-Z_$][a-zA-Z0-9_$]*)\s*\(/gm,
   ];
 
-  const names = patterns.flatMap((r) => matchAll(r, content).map((m) => m[1]));
-  return [...new Set(names)].filter(
-    (n) => n !== 'constructor' && !n.startsWith('_') && !JS_RESERVED.has(n),
-  );
+  const seen = new Set();
+  const results = [];
+
+  patterns.forEach((r) => {
+    matchAll(r, content).forEach((m) => {
+      const name = m[1];
+      if (name === 'constructor' || name.startsWith('_') || JS_RESERVED.has(name)) return;
+      if (seen.has(name)) return;
+      seen.add(name);
+      const line = content.substring(0, m.index).split('\n').length - 1;
+      const lineText = content.split('\n')[line];
+      const col = lineText.indexOf(name);
+      results.push({ name, line, col: col >= 0 ? col : 0 });
+    });
+  });
+
+  return results;
 }
 
 function isCustomService(filePath) {
@@ -64,6 +81,7 @@ module.exports = {
   pascalCase,
   matchAll,
   extractMethods,
+  extractMethodsWithLocations,
   isCustomService,
   scanJsFilesRecursively,
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "langaro-api",
-  "version": "1.0.6",
+  "version": "1.0.8",
   "description": "Auto-generate TypeScript types, JSDoc annotations, and boilerplate loaders for knex-extended-crud projects",
   "main": "lib/index.js",
   "bin": {
@@ -21,8 +21,8 @@
     "boilerplate"
   ],
   "peerDependencies": {
-    "knex-extended-crud": ">=2.0.31",
-    "cron": ">=3.0.0"
+    "cron": ">=3.0.0",
+    "knex-extended-crud": ">=2.0.31"
   },
   "peerDependenciesMeta": {
     "cron": {