@ciwergrp/nuxid 1.1.1 → 1.1.3

package/bin/nuxid.mjs

@@ -13,6 +13,7 @@ function printHelp() {
   console.log('Usage: pnpm nuxid <command> [options]\n');
   console.log('Commands:');
   console.log('  make:request <name>    Interactive generator for request validation files');
+  console.log('  make:resource <name>   Interactive generator for api resource modules');
   console.log('\nUse `pnpm nuxid <command> --help` for more information.\n');
 }
 
@@ -31,6 +32,14 @@ if (command === 'make:request') {
 
   child.on('exit', code => process.exit(code ?? 0));
 }
+else if (command === 'make:resource') {
+  const scriptPath = path.join(__dirname, '../console/resource.mjs');
+  const child = spawn(process.execPath, [scriptPath, ...rest], {
+    stdio: 'inherit',
+  });
+
+  child.on('exit', code => process.exit(code ?? 0));
+}
 else if (command === '--help' || command === '-h') {
   printHelp();
 }

package/console/request.mjs

@@ -21,9 +21,18 @@ const availableRules = [
   'alpha',
   'alpha_num',
   'alpha_dash',
+  'alphanumeric_space',
+  'alpha_space',
   'numeric',
   'integer',
+  'bail',
   'date',
+  'before',
+  'after',
+  'array',
+  'url',
+  'ip',
+  'hex_color',
   'min',
   'max',
   'same',
@@ -32,8 +41,10 @@ const availableRules = [
   'gte',
   'lt',
   'lte',
+  'in',
   'starts_with',
   'ends_with',
+  'regex',
 ];
 
 const parameterizedRules = new Set([
@@ -48,6 +59,9 @@ const parameterizedRules = new Set([
   'starts_with',
   'ends_with',
   'regex',
+  'before',
+  'after',
+  'in',
 ]);
 
 function toCamelCase(str) {

package/console/resource.mjs

@@ -0,0 +1,451 @@
+import { exec } from 'node:child_process';
+import fs from 'node:fs';
+import path from 'node:path';
+import { cwd } from 'node:process';
+import { confirm, input } from '@inquirer/prompts';
+
+const colors = {
+  reset: '\x1B[0m',
+  cyan: '\x1B[36m',
+  yellow: '\x1B[33m',
+  green: '\x1B[32m',
+  red: '\x1B[31m',
+  dim: '\x1B[2m',
+};
+
+function displayHeader(title) {
+  const width = title.length + 4;
+  const border = '─'.repeat(width);
+  console.log(`┌${border}┐`);
+  console.log(`│  ${colors.cyan}${title}${colors.reset}  │`);
+  console.log(`└${border}┘\n`);
+}
+
+function loadPrefixFromProjectConfig() {
+  const candidates = [
+    'nuxid.mjs',
+    'nuxid.cjs',
+    'nuxid.js',
+    'nuxid.ts',
+    'nuxid.json',
+    'nuxid.config.json',
+    'artisan.mjs',
+    'artisan.cjs',
+    'artisan.js',
+    'artisan.ts',
+    'artisan.json',
+    'artisan.config.json',
+    'package.json',
+  ];
+
+  for (const file of candidates) {
+    const p = path.join(cwd(), file);
+    if (!fs.existsSync(p)) {
+      continue;
+    }
+
+    try {
+      if (file.endsWith('.json')) {
+        const raw = fs.readFileSync(p, 'utf8');
+        const obj = JSON.parse(raw);
+        if (file === 'package.json') {
+          if (obj?.nuxid && typeof obj.nuxid.prefix === 'string') {
+            return obj.nuxid.prefix;
+          }
+          if (obj?.artisan && typeof obj.artisan.prefix === 'string') {
+            return obj.artisan.prefix;
+          }
+        }
+        if (typeof obj?.prefix === 'string') {
+          return obj.prefix;
+        }
+      }
+
+      if (file.endsWith('.js') || file.endsWith('.mjs') || file.endsWith('.cjs') || file.endsWith('.ts')) {
+        const raw = fs.readFileSync(p, 'utf8');
+        const m = raw.match(/prefix\s*:\s*['"`]([^'"`]+)['"`]/);
+        if (m && m[1] !== undefined) {
+          return m[1];
+        }
+        const mEmpty = raw.match(/prefix\s*:\s*['"`]['"`]/);
+        if (mEmpty) {
+          return '';
+        }
+      }
+    }
+    catch (err) {
+      console.error(`${colors.red}Failed to read config ${file}: ${err.message}${colors.reset}`);
+    }
+  }
+
+  return undefined;
+}
+
+function loadResourceCaseFromProjectConfig() {
+  const candidates = [
+    'nuxid.mjs',
+    'nuxid.cjs',
+    'nuxid.js',
+    'nuxid.ts',
+    'nuxid.json',
+    'nuxid.config.json',
+    'artisan.mjs',
+    'artisan.cjs',
+    'artisan.js',
+    'artisan.ts',
+    'artisan.json',
+    'artisan.config.json',
+    'package.json',
+  ];
+
+  for (const file of candidates) {
+    const p = path.join(cwd(), file);
+    if (!fs.existsSync(p)) {
+      continue;
+    }
+
+    try {
+      if (file.endsWith('.json')) {
+        const raw = fs.readFileSync(p, 'utf8');
+        const obj = JSON.parse(raw);
+        if (file === 'package.json') {
+          if (obj?.nuxid?.resourceCase) {
+            return obj.nuxid.resourceCase;
+          }
+          if (obj?.nuxid?.resource?.case) {
+            return obj.nuxid.resource.case;
+          }
+          if (obj?.artisan?.resourceCase) {
+            return obj.artisan.resourceCase;
+          }
+          if (obj?.artisan?.resource?.case) {
+            return obj.artisan.resource.case;
+          }
+        }
+        if (obj?.resourceCase) {
+          return obj.resourceCase;
+        }
+        if (obj?.resource?.case) {
+          return obj.resource.case;
+        }
+      }
+
+      if (file.endsWith('.js') || file.endsWith('.mjs') || file.endsWith('.cjs') || file.endsWith('.ts')) {
+        const raw = fs.readFileSync(p, 'utf8');
+        const m = raw.match(/resourceCase\s*:\s*['"`]([^'"`]+)['"`]/);
+        if (m && m[1] !== undefined) {
+          return m[1];
+        }
+      }
+    }
+    catch (err) {
+      console.error(`${colors.red}Failed to read config ${file}: ${err.message}${colors.reset}`);
+    }
+  }
+
+  return undefined;
+}
+
+function toKebabCase(value) {
+  return value
+    .trim()
+    .replace(/([a-z0-9])([A-Z])/g, '$1-$2')
+    .replace(/[_\s]+/g, '-')
+    .replace(/-+/g, '-')
+    .toLowerCase();
+}
+
+function toWords(value) {
+  return value
+    .trim()
+    .replace(/([a-z0-9])([A-Z])/g, '$1 $2')
+    .replace(/[_\-\s]+/g, ' ')
+    .split(' ')
+    .map(word => word.toLowerCase())
+    .filter(Boolean);
+}
+
+function capitalize(value) {
+  return value ? value[0].toUpperCase() + value.slice(1) : '';
+}
+
+function toCase(value, caseStyle) {
+  if (caseStyle === 'false') {
+    return value;
+  }
+
+  const words = toWords(value);
+  if (caseStyle === 'snake') {
+    return words.join('_');
+  }
+  if (caseStyle === 'upper-snake') {
+    return words.join('_').toUpperCase();
+  }
+  if (caseStyle === 'pascal') {
+    return words.map(capitalize).join('');
+  }
+  if (caseStyle === 'camel') {
+    const [first, ...rest] = words;
+    return `${first || ''}${rest.map(capitalize).join('')}`;
+  }
+
+  return value;
+}
+
+function isValidIdentifier(name) {
+  return /^[A-Z_$][\w$]*$/i.test(name);
+}
+
+function toSafeIdentifier(name) {
+  const candidate = toCase(name, 'camel').replace(/[^\w$]/g, '');
+  if (candidate && isValidIdentifier(candidate)) {
+    return candidate;
+  }
+  return `_${candidate || 'module'}`;
+}
+
+function normalizeCaseOption(value) {
+  if (value === false) {
+    return 'false';
+  }
+  if (typeof value !== 'string') {
+    return 'camel';
+  }
+  const normalized = value.trim().toLowerCase();
+  if (['camel', 'snake', 'pascal', 'upper-snake', 'false'].includes(normalized)) {
+    return normalized;
+  }
+  return 'camel';
+}
+
+function getCrudTemplate(moduleName, caseStyle) {
+  const useIndexName = toCase('useIndex', caseStyle);
+  const useShowName = toCase('useShow', caseStyle);
+  return `
+import type { UseFetchOptions } from '#app';
+import type { NitroFetchOptions, NitroFetchRequest } from 'nitropack';
+
+export async function index(options: NitroFetchOptions<NitroFetchRequest> = {}) {
+  return $fetch('/api/${moduleName}', options);
+}
+
+export async function show(id: string, options: NitroFetchOptions<NitroFetchRequest> = {}) {
+  return $fetch(\`/api/${moduleName}/\${id}\`, options);
+}
+
+export function ${useIndexName}<T = any>(options: UseFetchOptions<T> = {}) {
+  return useFetch<T>('/api/${moduleName}', options);
+}
+
+export function ${useShowName}<T = any>(id: string, options: UseFetchOptions<T> = {}) {
+  return useFetch<T>(\`/api/${moduleName}/\${id}\`, options);
+}
+
+export async function store(form: UseHttp, options: NitroFetchOptions<NitroFetchRequest> = {}) {
+  return form.post('/api/${moduleName}', options);
+}
+
+export async function update(form: UseHttp, id: string, options: NitroFetchOptions<NitroFetchRequest> = {}) {
+  return form.patch(\`/api/${moduleName}/\${id}\`, options);
+}
+
+export async function destroy(id: string, options: NitroFetchOptions<NitroFetchRequest> = {}) {
+  return $fetch(\`/api/${moduleName}/\${id}\`, { method: 'DELETE', ...options });
+}
+`;
+}
+
+function getImmediateDirectories(dir) {
+  const results = [];
+  try {
+    const list = fs.readdirSync(dir, { withFileTypes: true });
+    for (const dirent of list) {
+      if (dirent.isDirectory()) {
+        results.push(path.resolve(dir, dirent.name));
+      }
+    }
+  }
+  catch (error) {
+    console.error(`${colors.red}Error reading directory ${dir}: ${error.message}${colors.reset}`);
+  }
+
+  return results;
+}
+
+function reindexApiModules(baseDir, caseStyle) {
+  const modulesDir = path.join(baseDir, 'api', 'modules');
+  const indexFile = path.join(baseDir, 'api', 'index.ts');
+  const directories = getImmediateDirectories(modulesDir);
+  const imports = [];
+  const exports = [];
+
+  directories.forEach((dir) => {
+    const folderName = path.basename(dir);
+    const exportName = toCase(folderName, caseStyle);
+    const safeAlias = isValidIdentifier(exportName) ? exportName : toSafeIdentifier(folderName);
+    const modulePath = `./modules/${folderName}/index`;
+
+    if (safeAlias) {
+      imports.push(`import * as ${safeAlias} from '${modulePath}';`);
+      if (isValidIdentifier(exportName)) {
+        exports.push(`  ${exportName},`);
+      }
+      else {
+        exports.push(`  '${exportName}': ${safeAlias},`);
+      }
+    }
+  });
+
+  const indexContent = `
+${imports.join('\n')}
+
+export const api = {
+  ${exports.join('')}
+};
+
+export type Api = typeof api;`;
+
+  fs.writeFileSync(indexFile, indexContent.trim(), 'utf8');
+}
+
+function runLinter(filePath) {
+  console.log(`\n${colors.dim}Running linter...${colors.reset}`);
+  const command = `npx eslint --fix "${filePath}"`;
+
+  exec(command, (error, _stdout, stderr) => {
+    if (error) {
+      console.error(`\n${colors.red}Error running linter on ${filePath}: ${error.message}${colors.reset}`);
+      if (stderr) {
+        console.error(stderr);
+      }
+    }
+    else {
+      console.log(`${colors.green}✅ Linter finished successfully for: ${colors.dim}${filePath}${colors.reset}`);
+    }
+  });
+}
+
+async function run() {
+  const argv = process.argv.slice(2);
+  if (argv.includes('--help') || argv.includes('-h')) {
+    console.log('\nUsage: pnpm nuxid make:resource [options]\n');
+    console.log('Options:');
+    console.log('  -a, --app <name>      Target app under ./apps/<name>');
+    console.log('  -c, --case <style>    Case for api index entries (camel, snake, pascal, upper-snake, false)');
+    console.log('  -f, --full            Generate CRUD helpers');
+    console.log('  -p, --prefix <dir>    Override the target prefix (default: project\'s config or \'app\')');
+    console.log('  -h, --help            Show this help message\n');
+    console.log('Examples:');
+    console.log('  pnpm nuxid make:resource users --full');
+    console.log('  pnpm nuxid make:resource --full --app admin\n');
+    return;
+  }
+
+  console.clear();
+  displayHeader('Create New Resource Module');
+
+  const nameFromArgs = argv.find(arg => !arg.startsWith('-'));
+  const rawName = nameFromArgs || await input({
+    message: 'What is the name of the resource?',
+    validate: value => (value ? true : 'Name is required.'),
+  });
+
+  const moduleName = toKebabCase(rawName);
+  if (!moduleName) {
+    console.log(`\n${colors.dim}Invalid name provided. Exiting.${colors.reset}`);
+    return;
+  }
+
+  let appName;
+  let cliPrefix;
+  let cliCase;
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (a.startsWith('--app=')) {
+      appName = a.split('=')[1];
+    }
+    else if (a === '--app' && argv[i + 1] !== undefined) {
+      appName = argv[i + 1];
+    }
+    else if (a.startsWith('-a=')) {
+      appName = a.split('=')[1];
+    }
+    else if (a === '-a' && argv[i + 1] !== undefined) {
+      appName = argv[i + 1];
+    }
+    else if (a.startsWith('--prefix=')) {
+      cliPrefix = a.split('=')[1];
+    }
+    else if (a === '--prefix' && argv[i + 1] !== undefined) {
+      cliPrefix = argv[i + 1];
+    }
+    else if (a.startsWith('-p=')) {
+      cliPrefix = a.split('=')[1];
+    }
+    else if (a === '-p' && argv[i + 1] !== undefined) {
+      cliPrefix = argv[i + 1];
+    }
+    else if (a.startsWith('--case=')) {
+      cliCase = a.split('=')[1];
+    }
+    else if (a === '--case' && argv[i + 1] !== undefined) {
+      cliCase = argv[i + 1];
+    }
+    else if (a.startsWith('-c=')) {
+      cliCase = a.split('=')[1];
+    }
+    else if (a === '-c' && argv[i + 1] !== undefined) {
+      cliCase = argv[i + 1];
+    }
+  }
+
+  const isFull = argv.includes('--full') || argv.includes('-f');
+  const configuredPrefix = loadPrefixFromProjectConfig();
+  const configuredCase = loadResourceCaseFromProjectConfig();
+  const prefix = cliPrefix !== undefined
+    ? cliPrefix
+    : (typeof configuredPrefix === 'string' ? configuredPrefix : (appName ? 'app' : ''));
+  const caseStyle = normalizeCaseOption(cliCase ?? configuredCase ?? 'camel');
+  const baseDir = appName ? path.join(cwd(), 'apps', appName) : cwd();
+  const targetRoot = prefix === '' ? baseDir : path.join(baseDir, prefix);
+  const targetDir = path.join(targetRoot, 'api', 'modules', moduleName);
+  const targetPath = path.join(targetDir, 'index.ts');
+
+  const shownPrefix = prefix === '' ? '(project root)' : prefix;
+  const shownApp = appName ? `apps/${appName}` : '(project root)';
+  console.log(`${colors.dim}App: ${colors.cyan}${shownApp}${colors.reset}`);
+  console.log(`${colors.dim}Prefix: ${colors.cyan}${shownPrefix}${colors.reset}`);
+  console.log(`${colors.dim}Target: ${colors.cyan}${path.relative(cwd(), targetPath) || '.'}${colors.reset}`);
+  console.log(`${colors.dim}Mode: ${colors.cyan}${isFull ? 'full (CRUD)' : 'empty'}${colors.reset}`);
+
+  const writeFileAndLint = () => {
+    const content = isFull ? getCrudTemplate(moduleName, caseStyle).trim() : '';
+    fs.writeFileSync(targetPath, content, 'utf8');
+    console.log(`\n${colors.green}✅ Success! Created/updated module at: ${colors.dim}${path.relative(cwd(), targetPath)}${colors.reset}`);
+    reindexApiModules(targetRoot, caseStyle);
+    runLinter(targetPath);
+  };
+
+  if (!fs.existsSync(targetDir)) {
+    fs.mkdirSync(targetDir, { recursive: true });
+  }
+
+  if (fs.existsSync(targetPath)) {
+    const overwrite = await confirm({
+      message: 'index.ts already exists. Overwrite?',
+      default: false,
+    });
+
+    if (overwrite) {
+      writeFileAndLint();
+    }
+    else {
+      console.log(`\n${colors.dim}Operation cancelled.${colors.reset}`);
+    }
+  }
+  else {
+    writeFileAndLint();
+  }
+}
+
+run();

package/dist/module.json

@@ -1,7 +1,7 @@
 {
   "name": "@ciwergrp/nuxid",
   "configKey": "nuxid",
-  "version": "1.1.1",
+  "version": "1.1.3",
   "builder": {
     "@nuxt/module-builder": "1.0.2",
     "unbuild": "3.6.1"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ciwergrp/nuxid",
-  "version": "1.1.1",
+  "version": "1.1.3",
   "description": "All-in-one essential modules for Nuxt",
   "repository": {
     "type": "git",