langaro-api 1.0.0

package/bin/langaro-api.js

@@ -0,0 +1,55 @@
+#!/usr/bin/env node
+
+const fs = require('fs');
+const path = require('path');
+const { generateTypes, getWatchDirs } = require('../lib/index');
+
+// Load config from langaro-api.config.js at cwd, or use defaults
+function loadConfig() {
+  const configPath = path.resolve(process.cwd(), 'langaro-api.config.js');
+  if (fs.existsSync(configPath)) {
+    return require(configPath);
+  }
+  return {};
+}
+
+function run() {
+  const config = loadConfig();
+  generateTypes(config);
+  console.log('[langaro-api] Types + JSDoc annotations generated.');
+}
+
+// Initial run
+run();
+
+// Watch mode
+if (process.argv.includes('--watch')) {
+  const config = loadConfig();
+  const dirs = getWatchDirs(config);
+
+  let debounceTimer = null;
+
+  function onChange() {
+    if (debounceTimer) clearTimeout(debounceTimer);
+    debounceTimer = setTimeout(() => {
+      try {
+        run();
+      } catch (err) {
+        console.error('[langaro-api] Error:', err.message);
+      }
+    }, 300);
+  }
+
+  dirs.forEach((dir) => {
+    try {
+      fs.watch(dir, { recursive: true }, (eventType, filename) => {
+        if (filename && filename.endsWith('.js')) onChange();
+      });
+    } catch (err) {
+      // Directory might not support recursive watching on some platforms
+      console.warn(`[langaro-api] Could not watch ${dir}: ${err.message}`);
+    }
+  });
+
+  console.log(`[langaro-api] Watching ${dirs.length} directories for changes...`);
+}

package/lib/generators/controllers.js

@@ -0,0 +1,63 @@
+const fs = require('fs');
+const path = require('path');
+const { pascalCase, extractMethods } = require('../utils');
+
+function scanControllerEntries(controllersDir) {
+  const entries = [];
+  if (!fs.existsSync(controllersDir)) return entries;
+
+  fs.readdirSync(controllersDir).forEach((entry) => {
+    const fullPath = path.join(controllersDir, entry);
+    if (fs.statSync(fullPath).isDirectory()) {
+      fs.readdirSync(fullPath)
+        .filter((f) => f.endsWith('.controller.js'))
+        .forEach((f) => entries.push({
+          tableName: f.replace('.controller.js', ''),
+          filePath: path.join(fullPath, f),
+        }));
+    } else if (entry.endsWith('.controller.js')) {
+      entries.push({ tableName: entry.replace('.controller.js', ''), filePath: fullPath });
+    }
+  });
+  return entries.sort((a, b) => a.tableName.localeCompare(b.tableName));
+}
+
+function generateControllersDts(controllersDir) {
+  const lines = ['// Auto-generated by langaro-api — DO NOT EDIT', ''];
+  const controllerEntries = scanControllerEntries(controllersDir);
+
+  // Base classes for JSDoc @param on "ServicesClass"
+  controllerEntries.forEach(({ tableName }) => {
+    const pc = pascalCase(tableName);
+    lines.push(
+      `declare class ${pc}ControllerBase {`,
+      `  service: ServicesMap['${pc}Services'];`,
+      '  services: ServicesMap;',
+      '  Queue: QueueMap;',
+      '  io: any;',
+      '}',
+      '',
+    );
+  });
+
+  // Controller interfaces with their methods (for router autocomplete)
+  controllerEntries.forEach(({ tableName, filePath }) => {
+    const pc = pascalCase(tableName);
+    const methods = extractMethods(filePath);
+    lines.push(`declare interface I${pc}Controller extends ${pc}ControllerBase {`);
+    methods.forEach((m) => lines.push(`  ${m}(...args: any[]): any;`));
+    lines.push('}', '');
+  });
+
+  // ControllersMap — used to type the "controllers" param in routers
+  lines.push('declare interface ControllersMap {');
+  controllerEntries.forEach(({ tableName }) => {
+    const pc = pascalCase(tableName);
+    lines.push(`  ${pc}Controller: I${pc}Controller;`);
+  });
+  lines.push('}', '');
+
+  return lines.join('\n');
+}
+
+module.exports = { scanControllerEntries, generateControllersDts };

package/lib/generators/crud.js

@@ -0,0 +1,157 @@
+module.exports = function generateCrudDts() {
+  return [
+    '// 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;',
+    '}',
+    '',
+    'declare interface CRUDGetOptions {',
+    '  perPage?: number;',
+    '  currentPage?: number;',
+    '  append?: string[];',
+    '  appendOptions?: Record<string, any>;',
+    '  andWhere?: Array<[string, string, any]>;',
+    '  search?: string;',
+    '  searchExactMatch?: boolean;',
+    '  searchFields?: string[];',
+    '  firstOnly?: boolean;',
+    '  show?: string[];',
+    '  showOnly?: string[];',
+    '  sortBy?: string;',
+    "  sort?: 'asc' | 'desc';",
+    '  where?: (query: any) => any;',
+    '  [key: string]: any;',
+    '}',
+    '',
+    'declare interface CRUDUpdateOptions {',
+    '  allowForbiddenUpdates?: boolean;',
+    '  extraValidations?: Array<(data: any) => void>;',
+    '  where?: (query: any) => any;',
+    '  andWhere?: Array<[string, string, any]>;',
+    '  whenSuccess?: (data: any) => void;',
+    '  [key: string]: any;',
+    '}',
+    '',
+    'declare interface CRUDBatchUpdateOptions extends CRUDUpdateOptions {',
+    '  getItemBy?: string;',
+    '  socket?: any;',
+    '  [key: string]: any;',
+    '}',
+    '',
+    'declare interface CRUDDeleteOptions {',
+    '  where?: (query: any) => any;',
+    '  andWhere?: Array<[string, string, any]>;',
+    '  [key: string]: any;',
+    '}',
+    '',
+    'declare interface QueueMap {',
+    '  add(name: string, data?: any, options?: any): Promise<any>;',
+    '}',
+    '',
+    'declare interface ModelFilterOption {',
+    '  name: string;',
+    "  type: 'select_multiple' | 'date' | 'is_not_null';",
+    '  options?: any[];',
+    '  column?: string;',
+    '}',
+    '',
+    'declare interface ModelConfig {',
+    '  /** Fields hidden from API responses */',
+    '  hide?: string[];',
+    '  /** Relation mappings for appendItems */',
+    "  append?: Record<string, 'one' | 'many' | string>;",
+    '  /** Yup validation schema */',
+    '  schema?: any;',
+    '  /** Default sort column */',
+    '  sortBy?: string;',
+    '  /** Default sort direction */',
+    "  sort?: 'asc' | 'desc';",
+    '  /** Fields that are not searchable */',
+    '  notSearchableFields?: string[];',
+    '  /** Enable drag-and-drop sorting */',
+    '  sortable?: boolean;',
+    '  /** Force integer conversion for these fields */',
+    '  forceInteger?: string[];',
+    '  /** Override singular table name */',
+    '  singularTableName?: string;',
+    '  /** Override plural table name */',
+    '  pluralTableName?: string;',
+    '  /** Field specifications */',
+    '  fieldsSpec?: any[];',
+    '  /** Cache timeout in ms (default: 300000) */',
+    '  cacheTimeout?: number;',
+    '  /** Enable/disable schema cache */',
+    '  cacheEnabled?: boolean;',
+    '  fields?: {',
+    '    /** Fields not required when creating a record */',
+    '    notRequiredOnCreate?: string[];',
+    '    /** Fields that cannot be updated */',
+    '    notUpdatable?: string[];',
+    '    /** Searchable fields for text search */',
+    '    searchableFields?: string[];',
+    '    /** Filter options for list queries */',
+    '    filterOptions?: ModelFilterOption[];',
+    '  };',
+    '}',
+    '',
+  ].join('\n');
+};

package/lib/generators/index-dts.js

@@ -0,0 +1,9 @@
+module.exports = function generateIndexDts() {
+  return [
+    '// Auto-generated by langaro-api — DO NOT EDIT',
+    '/// <reference path="./crud.d.ts" />',
+    '/// <reference path="./services.d.ts" />',
+    '/// <reference path="./controllers.d.ts" />',
+    '',
+  ].join('\n');
+};

package/lib/generators/services.js

@@ -0,0 +1,86 @@
+const fs = require('fs');
+const path = require('path');
+const { pascalCase, extractMethods, isCustomService } = require('../utils');
+
+module.exports = function generateServicesDts(servicesDir, modelsDir) {
+  const lines = ['// Auto-generated by langaro-api — DO NOT EDIT', ''];
+  const serviceEntries = [];
+
+  // Services with custom .services.js files
+  if (fs.existsSync(servicesDir)) {
+    fs.readdirSync(servicesDir)
+      .filter((f) => f.endsWith('.services.js'))
+      .sort()
+      .forEach((file) => {
+        const tableName = file.replace('.services.js', '');
+        const serviceName = `${pascalCase(tableName)}Services`;
+        const interfaceName = `I${serviceName}`;
+        const filePath = path.join(servicesDir, file);
+        const custom = isCustomService(filePath);
+        const methods = extractMethods(filePath);
+
+        if (custom) {
+          lines.push(`declare interface ${interfaceName} {`);
+          lines.push('  table: string;');
+        } else {
+          lines.push(`declare interface ${interfaceName} extends CRUD {`);
+        }
+        methods.forEach((m) => lines.push(`  ${m}(...args: any[]): any;`));
+        lines.push('}', '');
+
+        serviceEntries.push({
+          interfaceName,
+          serviceName,
+          tableName,
+          custom,
+        });
+      });
+  }
+
+  // DB tables with .model.js but no .services.js — pure CRUD
+  if (fs.existsSync(modelsDir)) {
+    fs.readdirSync(modelsDir)
+      .filter((f) => f.endsWith('.model.js'))
+      .forEach((file) => {
+        const tableName = file.replace('.model.js', '');
+        const serviceName = `${pascalCase(tableName)}Services`;
+        if (serviceEntries.find((e) => e.serviceName === serviceName)) return;
+        const interfaceName = `I${serviceName}`;
+        lines.push(`declare interface ${interfaceName} extends CRUD {}`, '');
+        serviceEntries.push({
+          interfaceName,
+          serviceName,
+          tableName,
+          custom: false,
+        });
+      });
+  }
+
+  // ServicesMap
+  lines.push('declare interface ServicesMap {');
+  serviceEntries
+    .sort((a, b) => a.serviceName.localeCompare(b.serviceName))
+    .forEach(({ interfaceName, serviceName }) => {
+      lines.push(`  ${serviceName}: ${interfaceName};`);
+    });
+  lines.push('}', '');
+
+  // ModelsConstructorMap — typed table names for "new models.xxx()"
+  lines.push('declare interface ModelsConstructorMap {');
+  serviceEntries
+    .filter(({ custom }) => !custom)
+    .sort((a, b) => a.tableName.localeCompare(b.tableName))
+    .forEach(({ tableName }) => {
+      lines.push(`  ${tableName}: new () => CRUD;`);
+    });
+  lines.push('  [key: string]: new () => CRUD;');
+  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 {}`);
+  });
+  lines.push('');
+
+  return lines.join('\n');
+};

package/lib/index.js

@@ -0,0 +1,82 @@
+const fs = require('fs');
+const path = require('path');
+
+const generateCrudDts = require('./generators/crud');
+const generateServicesDts = require('./generators/services');
+const { generateControllersDts } = require('./generators/controllers');
+const generateIndexDts = require('./generators/index-dts');
+const {
+  injectControllerAnnotations,
+  injectServiceAnnotations,
+  injectRouterAnnotations,
+  injectModelAnnotations,
+  injectJobAnnotations,
+  injectTaskAnnotations,
+  injectMiddlewareAnnotations,
+} = require('./inject');
+
+const DEFAULTS = {
+  root: process.cwd(),
+  output: '@types/generated',
+  services: 'src/database/services',
+  models: 'src/database/models',
+  controllers: 'src/controllers',
+  routes: 'src/routes',
+  jobs: 'src/jobs',
+  tasks: 'src/tasks',
+  middlewares: 'src/middlewares',
+};
+
+function generateTypes(userConfig = {}) {
+  const config = { ...DEFAULTS, ...userConfig };
+  const root = config.root;
+
+  const resolve = (dir) => path.resolve(root, dir);
+
+  const outputDir = resolve(config.output);
+  const servicesDir = resolve(config.services);
+  const modelsDir = resolve(config.models);
+  const controllersDir = resolve(config.controllers);
+  const routesDir = resolve(config.routes);
+  const jobsDir = resolve(config.jobs);
+  const tasksDir = resolve(config.tasks);
+  const middlewaresDir = resolve(config.middlewares);
+
+  // 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));
+  fs.writeFileSync(path.join(outputDir, 'index.d.ts'), generateIndexDts());
+
+  // Inject JSDoc annotations into source files
+  injectControllerAnnotations(controllersDir);
+  injectServiceAnnotations(servicesDir);
+  injectRouterAnnotations(routesDir);
+  injectModelAnnotations(modelsDir);
+  injectJobAnnotations(jobsDir);
+  injectTaskAnnotations(tasksDir);
+  injectMiddlewareAnnotations(middlewaresDir);
+
+  return { outputDir, config };
+}
+
+function getWatchDirs(userConfig = {}) {
+  const config = { ...DEFAULTS, ...userConfig };
+  const root = config.root;
+  const resolve = (dir) => path.resolve(root, dir);
+
+  return [
+    config.services,
+    config.models,
+    config.controllers,
+    config.routes,
+    config.jobs,
+    config.tasks,
+    config.middlewares,
+  ]
+    .map(resolve)
+    .filter((dir) => fs.existsSync(dir));
+}
+
+module.exports = { generateTypes, getWatchDirs, DEFAULTS };

package/lib/inject.js

@@ -0,0 +1,123 @@
+const fs = require('fs');
+const path = require('path');
+const { JSDOC_MARKER, pascalCase, isCustomService, scanJsFilesRecursively } = require('./utils');
+const { scanControllerEntries } = require('./generators/controllers');
+
+function injectJSDoc(filePath, jsdocComment, targetLineRegex) {
+  const content = fs.readFileSync(filePath, 'utf8');
+  const lines = content.split('\n');
+
+  const targetIdx = lines.findIndex((line) => targetLineRegex.test(line));
+  if (targetIdx === -1) return false;
+
+  // Search up to 3 lines above target for existing marker (handles eslint-disable comments between)
+  let existingIdx = -1;
+  const searchRange = Math.min(3, targetIdx);
+  for (let i = 1; i <= searchRange; i += 1) {
+    if (lines[targetIdx - i].includes(JSDOC_MARKER)) {
+      existingIdx = targetIdx - i;
+      break;
+    }
+  }
+
+  if (existingIdx !== -1) {
+    if (lines[existingIdx] === jsdocComment) return true; // already up-to-date
+    lines[existingIdx] = jsdocComment;
+  } else {
+    lines.splice(targetIdx, 0, jsdocComment);
+  }
+
+  fs.writeFileSync(filePath, lines.join('\n'));
+  return true;
+}
+
+function injectControllerAnnotations(controllersDir) {
+  scanControllerEntries(controllersDir).forEach(({ filePath, tableName }) => {
+    const baseName = `${pascalCase(tableName)}ControllerBase`;
+    const jsdoc = `/** @param {typeof ${baseName}} ServicesClass ${JSDOC_MARKER} */`;
+    injectJSDoc(filePath, jsdoc, /module\.exports\s*=\s*\(\s*ServicesClass\s*\)/);
+  });
+}
+
+function injectRouterAnnotations(routesDir) {
+  if (!fs.existsSync(routesDir)) return;
+  fs.readdirSync(routesDir)
+    .filter((f) => f.endsWith('.router.js'))
+    .forEach((file) => {
+      const filePath = path.join(routesDir, file);
+      const jsdocBoth = `/** @param {ControllersMap} controllers @param {ServicesMap} services ${JSDOC_MARKER} */`;
+      if (injectJSDoc(filePath, jsdocBoth, /module\.exports\s*=\s*\(\s*controllers\s*,\s*services\s*\)/)) return;
+      const jsdocOnly = `/** @param {ControllersMap} controllers ${JSDOC_MARKER} */`;
+      injectJSDoc(filePath, jsdocOnly, /module\.exports\s*=\s*\(\s*controllers\s*\)/);
+    });
+}
+
+function injectMiddlewareAnnotations(middlewaresDir) {
+  if (!fs.existsSync(middlewaresDir)) return;
+  fs.readdirSync(middlewaresDir)
+    .filter((f) => f.endsWith('.js'))
+    .forEach((file) => {
+      const filePath = path.join(middlewaresDir, file);
+      const jsdoc = `/** @param {ServicesMap} services ${JSDOC_MARKER} */`;
+      injectJSDoc(filePath, jsdoc, /module\.exports\s*=\s*(function\s*)?\(\s*services\s*\)/);
+    });
+}
+
+function injectModelAnnotations(modelsDir) {
+  if (!fs.existsSync(modelsDir)) return;
+  fs.readdirSync(modelsDir)
+    .filter((f) => f.endsWith('.model.js'))
+    .forEach((file) => {
+      const filePath = path.join(modelsDir, file);
+      const jsdoc = `/** @type {ModelConfig} ${JSDOC_MARKER} */`;
+      injectJSDoc(filePath, jsdoc, /module\.exports\s*=\s*\{/);
+    });
+}
+
+function injectJobAnnotations(jobsDir) {
+  if (!fs.existsSync(jobsDir)) return;
+  scanJsFilesRecursively(jobsDir).forEach((filePath) => {
+    const jsdoc = `/** @param {ServicesMap} services ${JSDOC_MARKER} */`;
+    injectJSDoc(filePath, jsdoc, /module\.exports\s*=\s*\(\s*services\s*\)\s*=>\s*\(\{/);
+  });
+}
+
+function injectTaskAnnotations(tasksDir) {
+  if (!fs.existsSync(tasksDir)) return;
+  scanJsFilesRecursively(tasksDir).forEach((filePath) => {
+    const jsdocWithQueue = `/** @param {ServicesMap} services @param {QueueMap} queue ${JSDOC_MARKER} */`;
+    if (injectJSDoc(filePath, jsdocWithQueue, /module\.exports\s*=\s*\(\s*services\s*,\s*[qQ]ueue\s*\)\s*=>\s*\{/)) return;
+    const jsdocNoQueue = `/** @param {ServicesMap} services ${JSDOC_MARKER} */`;
+    injectJSDoc(filePath, jsdocNoQueue, /module\.exports\s*=\s*\(\s*services\s*\)\s*=>\s*\{/);
+  });
+}
+
+function injectServiceAnnotations(servicesDir) {
+  if (!fs.existsSync(servicesDir)) return;
+  fs.readdirSync(servicesDir)
+    .filter((f) => f.endsWith('.services.js'))
+    .forEach((file) => {
+      const filePath = path.join(servicesDir, file);
+      const tableName = file.replace('.services.js', '');
+      const custom = isCustomService(filePath);
+
+      if (custom) {
+        const jsdoc = `/** @param {ModelsConstructorMap} models ${JSDOC_MARKER} */`;
+        injectJSDoc(filePath, jsdoc, /module\.exports\s*=\s*\(\s*models\s*(?:,\s*io)?\s*\)\s*=>\s*class/);
+      } else {
+        const baseName = `${pascalCase(tableName)}ServicesBase`;
+        const jsdoc = `/** @param {typeof ${baseName}} model @param {ModelsConstructorMap} models ${JSDOC_MARKER} */`;
+        injectJSDoc(filePath, jsdoc, /module\.exports\s*=\s*\(\s*model/);
+      }
+    });
+}
+
+module.exports = {
+  injectControllerAnnotations,
+  injectServiceAnnotations,
+  injectRouterAnnotations,
+  injectModelAnnotations,
+  injectJobAnnotations,
+  injectTaskAnnotations,
+  injectMiddlewareAnnotations,
+};

package/lib/utils.js

@@ -0,0 +1,69 @@
+const fs = require('fs');
+
+const JSDOC_MARKER = '@generated-types';
+
+const JS_RESERVED = new Set([
+  'break', 'case', 'catch', 'continue', 'debugger', 'default', 'delete',
+  'do', 'else', 'finally', 'for', 'function', 'if', 'in', 'instanceof',
+  'new', 'return', 'switch', 'this', 'throw', 'try', 'typeof', 'var',
+  'void', 'while', 'with', 'class', 'const', 'enum', 'export', 'extends',
+  'import', 'super', 'implements', 'interface', 'let', 'package', 'private',
+  'protected', 'public', 'static', 'yield', 'await', 'async',
+]);
+
+function pascalCase(str) {
+  return str
+    .split(/[_\-\s]+/)
+    .map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase())
+    .join('');
+}
+
+function matchAll(regex, text) {
+  const results = [];
+  let match;
+  while ((match = regex.exec(text)) !== null) results.push(match);
+  return results;
+}
+
+function extractMethods(filePath) {
+  const content = fs.readFileSync(filePath, 'utf8');
+
+  const patterns = [
+    /^\s+(?:async\s+)?([a-zA-Z_$][a-zA-Z0-9_$]*)\s*\([^)]*\)\s*\{/gm,
+    /this\.([a-zA-Z_$][a-zA-Z0-9_$]*)\s*=\s*[a-zA-Z_$][a-zA-Z0-9_$]*\.bind\(this\)/g,
+    /^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),
+  );
+}
+
+function isCustomService(filePath) {
+  const content = fs.readFileSync(filePath, 'utf8');
+  return /module\.exports\s*=\s*\(\s*models\s*(?:,\s*io)?\s*\)\s*=>\s*class\s*\{/.test(content);
+}
+
+function scanJsFilesRecursively(dir) {
+  const results = [];
+  fs.readdirSync(dir).forEach((entry) => {
+    const fullPath = require('path').join(dir, entry);
+    if (fs.statSync(fullPath).isDirectory()) {
+      results.push(...scanJsFilesRecursively(fullPath));
+    } else if (entry.endsWith('.js') && !entry.endsWith('.spec.js') && entry !== 'index.js') {
+      results.push(fullPath);
+    }
+  });
+  return results;
+}
+
+module.exports = {
+  JSDOC_MARKER,
+  JS_RESERVED,
+  pascalCase,
+  matchAll,
+  extractMethods,
+  isCustomService,
+  scanJsFilesRecursively,
+};

package/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "langaro-api",
+  "version": "1.0.0",
+  "description": "Auto-generate TypeScript types and JSDoc annotations for knex-extended-crud projects",
+  "main": "lib/index.js",
+  "bin": {
+    "langaro-api": "bin/langaro-api.js"
+  },
+  "files": [
+    "lib/",
+    "bin/"
+  ],
+  "keywords": [
+    "knex",
+    "crud",
+    "types",
+    "jsdoc",
+    "intellisense",
+    "knex-extended-crud"
+  ],
+  "author": "Fernando Langaro",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/fernandolangaro/langaro-api.git"
+  }
+}