nexu-app 2.0.0

package/templates/default/packages/cache/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "@repo/cache",
+  "version": "0.0.0",
+  "private": true,
+  "main": "./dist/index.js",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "lint": "eslint src/",
+    "lint:fix": "eslint src/ --fix",
+    "typecheck": "tsc --noEmit"
+  },
+  "devDependencies": {
+    "tsup": "^8.0.0",
+    "typescript": "^5.4.0"
+  }
+}

package/templates/default/packages/cache/src/index.ts

@@ -0,0 +1,137 @@
+export interface CacheOptions {
+  ttl?: number; // Time to live in milliseconds
+  maxSize?: number; // Maximum number of items
+}
+
+interface CacheEntry<T> {
+  value: T;
+  expiresAt?: number;
+}
+
+export class Cache<T = unknown> {
+  private store = new Map<string, CacheEntry<T>>();
+  private ttl?: number;
+  private maxSize?: number;
+
+  constructor(options: CacheOptions = {}) {
+    this.ttl = options.ttl;
+    this.maxSize = options.maxSize;
+  }
+
+  private isExpired(entry: CacheEntry<T>): boolean {
+    if (!entry.expiresAt) return false;
+    return Date.now() > entry.expiresAt;
+  }
+
+  private evictIfNeeded(): void {
+    if (!this.maxSize || this.store.size < this.maxSize) return;
+
+    // Remove expired entries first
+    for (const [key, entry] of this.store) {
+      if (this.isExpired(entry)) {
+        this.store.delete(key);
+      }
+    }
+
+    // If still over limit, remove oldest entries
+    if (this.store.size >= this.maxSize) {
+      const keysToDelete = this.store.size - this.maxSize + 1;
+      const keys = Array.from(this.store.keys()).slice(0, keysToDelete);
+      keys.forEach(key => this.store.delete(key));
+    }
+  }
+
+  get(key: string): T | undefined {
+    const entry = this.store.get(key);
+    if (!entry) return undefined;
+
+    if (this.isExpired(entry)) {
+      this.store.delete(key);
+      return undefined;
+    }
+
+    return entry.value;
+  }
+
+  set(key: string, value: T, ttl?: number): void {
+    this.evictIfNeeded();
+
+    const effectiveTtl = ttl ?? this.ttl;
+    const entry: CacheEntry<T> = {
+      value,
+      expiresAt: effectiveTtl ? Date.now() + effectiveTtl : undefined,
+    };
+
+    this.store.set(key, entry);
+  }
+
+  has(key: string): boolean {
+    return this.get(key) !== undefined;
+  }
+
+  delete(key: string): boolean {
+    return this.store.delete(key);
+  }
+
+  clear(): void {
+    this.store.clear();
+  }
+
+  size(): number {
+    // Clean expired entries first
+    for (const [key, entry] of this.store) {
+      if (this.isExpired(entry)) {
+        this.store.delete(key);
+      }
+    }
+    return this.store.size;
+  }
+
+  keys(): string[] {
+    return Array.from(this.store.keys()).filter(key => this.has(key));
+  }
+
+  values(): T[] {
+    return this.keys().map(key => this.get(key)!);
+  }
+
+  entries(): [string, T][] {
+    return this.keys().map(key => [key, this.get(key)!]);
+  }
+
+  async getOrSet(key: string, factory: () => T | Promise<T>, ttl?: number): Promise<T> {
+    const cached = this.get(key);
+    if (cached !== undefined) return cached;
+
+    const value = await factory();
+    this.set(key, value, ttl);
+    return value;
+  }
+}
+
+// Memoization helper
+export function memoize<T extends (...args: unknown[]) => unknown>(
+  fn: T,
+  options: CacheOptions & { keyFn?: (...args: Parameters<T>) => string } = {}
+): T {
+  const cache = new Cache<ReturnType<T>>(options);
+  const keyFn = options.keyFn ?? ((...args) => JSON.stringify(args));
+
+  return ((...args: Parameters<T>) => {
+    const key = keyFn(...args);
+    const cached = cache.get(key);
+    if (cached !== undefined) return cached;
+
+    const result = fn(...args) as ReturnType<T>;
+    cache.set(key, result);
+    return result;
+  }) as T;
+}
+
+// Default cache instance
+export const cache = new Cache();
+
+// Factory function
+export function createCache<T = unknown>(options: CacheOptions = {}): Cache<T> {
+  return new Cache<T>(options);
+}

package/templates/default/packages/cache/tsconfig.json

@@ -0,0 +1,9 @@
+{
+  "extends": "../config/typescript/base.json",
+  "compilerOptions": {
+    "outDir": "./dist",
+    "rootDir": "./src"
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}

package/templates/default/packages/cache/tsup.config.ts

@@ -0,0 +1,9 @@
+import { defineConfig } from 'tsup';
+
+export default defineConfig({
+  entry: ['src/index.ts'],
+  format: ['cjs', 'esm'],
+  dts: true,
+  clean: true,
+  sourcemap: true,
+});

package/templates/default/packages/config/eslint/index.js

@@ -0,0 +1,20 @@
+module.exports = {
+  extends: ['eslint:recommended', 'plugin:@typescript-eslint/recommended', 'prettier'],
+  parser: '@typescript-eslint/parser',
+  plugins: ['@typescript-eslint', 'import'],
+  rules: {
+    '@typescript-eslint/no-unused-vars': ['warn', { argsIgnorePattern: '^_' }],
+    '@typescript-eslint/no-explicit-any': 'warn',
+    'import/order': [
+      'error',
+      {
+        groups: ['builtin', 'external', 'internal', 'parent', 'sibling', 'index'],
+        'newlines-between': 'always',
+        alphabetize: { order: 'asc', caseInsensitive: true },
+      },
+    ],
+    'no-console': ['warn', { allow: ['warn', 'error'] }],
+    'prefer-const': 'error',
+  },
+  ignorePatterns: ['node_modules', 'dist', '.next', 'coverage'],
+};

package/templates/default/packages/config/package.json

@@ -0,0 +1,9 @@
+{
+  "name": "@repo/config",
+  "version": "0.0.0",
+  "private": true,
+  "exports": {
+    "./eslint": "./eslint/index.js",
+    "./typescript/base": "./typescript/base.json"
+  }
+}

package/templates/default/packages/config/typescript/base.json

@@ -0,0 +1,26 @@
+{
+  "$schema": "https://json.schemastore.org/tsconfig",
+  "compilerOptions": {
+    "target": "ES2022",
+    "lib": ["ES2022"],
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "resolveJsonModule": true,
+    "allowJs": true,
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+    "strict": true,
+    "noImplicitAny": true,
+    "strictNullChecks": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "noFallthroughCasesInSwitch": true,
+    "esModuleInterop": true,
+    "allowSyntheticDefaultImports": true,
+    "forceConsistentCasingInFileNames": true,
+    "skipLibCheck": true,
+    "isolatedModules": true
+  },
+  "exclude": ["node_modules", "dist"]
+}

package/templates/default/packages/constants/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "@repo/constants",
+  "version": "0.0.0",
+  "private": true,
+  "main": "./dist/index.js",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "lint": "eslint src/",
+    "lint:fix": "eslint src/ --fix",
+    "typecheck": "tsc --noEmit"
+  },
+  "devDependencies": {
+    "tsup": "^8.0.0",
+    "typescript": "^5.4.0"
+  }
+}

package/templates/default/packages/constants/src/index.ts

@@ -0,0 +1,121 @@
+// HTTP Status Codes
+export const HTTP_STATUS = {
+  // Success
+  OK: 200,
+  CREATED: 201,
+  ACCEPTED: 202,
+  NO_CONTENT: 204,
+
+  // Redirection
+  MOVED_PERMANENTLY: 301,
+  FOUND: 302,
+  NOT_MODIFIED: 304,
+
+  // Client Errors
+  BAD_REQUEST: 400,
+  UNAUTHORIZED: 401,
+  FORBIDDEN: 403,
+  NOT_FOUND: 404,
+  METHOD_NOT_ALLOWED: 405,
+  CONFLICT: 409,
+  UNPROCESSABLE_ENTITY: 422,
+  TOO_MANY_REQUESTS: 429,
+
+  // Server Errors
+  INTERNAL_SERVER_ERROR: 500,
+  NOT_IMPLEMENTED: 501,
+  BAD_GATEWAY: 502,
+  SERVICE_UNAVAILABLE: 503,
+  GATEWAY_TIMEOUT: 504,
+} as const;
+
+export type HttpStatus = (typeof HTTP_STATUS)[keyof typeof HTTP_STATUS];
+
+// Error Codes
+export const ERROR_CODE = {
+  // Authentication
+  AUTH_INVALID_CREDENTIALS: 'AUTH_INVALID_CREDENTIALS',
+  AUTH_TOKEN_EXPIRED: 'AUTH_TOKEN_EXPIRED',
+  AUTH_TOKEN_INVALID: 'AUTH_TOKEN_INVALID',
+  AUTH_UNAUTHORIZED: 'AUTH_UNAUTHORIZED',
+  AUTH_FORBIDDEN: 'AUTH_FORBIDDEN',
+
+  // Validation
+  VALIDATION_FAILED: 'VALIDATION_FAILED',
+  VALIDATION_REQUIRED: 'VALIDATION_REQUIRED',
+  VALIDATION_INVALID_FORMAT: 'VALIDATION_INVALID_FORMAT',
+
+  // Resource
+  RESOURCE_NOT_FOUND: 'RESOURCE_NOT_FOUND',
+  RESOURCE_ALREADY_EXISTS: 'RESOURCE_ALREADY_EXISTS',
+  RESOURCE_CONFLICT: 'RESOURCE_CONFLICT',
+
+  // Rate Limiting
+  RATE_LIMIT_EXCEEDED: 'RATE_LIMIT_EXCEEDED',
+
+  // Server
+  INTERNAL_ERROR: 'INTERNAL_ERROR',
+  SERVICE_UNAVAILABLE: 'SERVICE_UNAVAILABLE',
+  DATABASE_ERROR: 'DATABASE_ERROR',
+  EXTERNAL_SERVICE_ERROR: 'EXTERNAL_SERVICE_ERROR',
+} as const;
+
+export type ErrorCode = (typeof ERROR_CODE)[keyof typeof ERROR_CODE];
+
+// User Roles
+export const USER_ROLE = {
+  ADMIN: 'admin',
+  USER: 'user',
+  GUEST: 'guest',
+} as const;
+
+export type UserRole = (typeof USER_ROLE)[keyof typeof USER_ROLE];
+
+// Pagination
+export const PAGINATION = {
+  DEFAULT_PAGE: 1,
+  DEFAULT_LIMIT: 20,
+  MAX_LIMIT: 100,
+} as const;
+
+// Date/Time
+export const TIME = {
+  SECOND: 1000,
+  MINUTE: 60 * 1000,
+  HOUR: 60 * 60 * 1000,
+  DAY: 24 * 60 * 60 * 1000,
+  WEEK: 7 * 24 * 60 * 60 * 1000,
+} as const;
+
+// Regex Patterns
+export const REGEX = {
+  EMAIL: /^[^\s@]+@[^\s@]+\.[^\s@]+$/,
+  UUID: /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i,
+  SLUG: /^[a-z0-9]+(?:-[a-z0-9]+)*$/,
+  PHONE: /^\+?[1-9]\d{1,14}$/,
+  URL: /^https?:\/\/.+/,
+} as const;
+
+// Mime Types
+export const MIME_TYPE = {
+  JSON: 'application/json',
+  HTML: 'text/html',
+  TEXT: 'text/plain',
+  XML: 'application/xml',
+  PDF: 'application/pdf',
+  PNG: 'image/png',
+  JPEG: 'image/jpeg',
+  GIF: 'image/gif',
+  SVG: 'image/svg+xml',
+} as const;
+
+export type MimeType = (typeof MIME_TYPE)[keyof typeof MIME_TYPE];
+
+// Environment
+export const ENV = {
+  DEVELOPMENT: 'development',
+  PRODUCTION: 'production',
+  TEST: 'test',
+} as const;
+
+export type Environment = (typeof ENV)[keyof typeof ENV];

package/templates/default/packages/constants/tsconfig.json

@@ -0,0 +1,9 @@
+{
+  "extends": "../config/typescript/base.json",
+  "compilerOptions": {
+    "outDir": "./dist",
+    "rootDir": "./src"
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}

package/templates/default/packages/constants/tsup.config.ts

@@ -0,0 +1,9 @@
+import { defineConfig } from 'tsup';
+
+export default defineConfig({
+  entry: ['src/index.ts'],
+  format: ['cjs', 'esm'],
+  dts: true,
+  clean: true,
+  sourcemap: true,
+});

package/templates/default/packages/logger/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "@repo/logger",
+  "version": "0.0.0",
+  "private": true,
+  "main": "./dist/index.js",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "lint": "eslint src/",
+    "lint:fix": "eslint src/ --fix",
+    "typecheck": "tsc --noEmit"
+  },
+  "devDependencies": {
+    "@types/node": "^25.0.9",
+    "tsup": "^8.0.0",
+    "typescript": "^5.4.0"
+  }
+}

package/templates/default/packages/logger/src/index.ts

@@ -0,0 +1,197 @@
+export type LogLevel = 'debug' | 'info' | 'warn' | 'error' | 'silent';
+
+export interface LogContext {
+  [key: string]: unknown;
+}
+
+export interface LoggerOptions {
+  level?: LogLevel;
+  prefix?: string;
+  timestamp?: boolean;
+  colors?: boolean;
+  json?: boolean;
+}
+
+interface LogEntry {
+  timestamp: string;
+  level: LogLevel;
+  message: string;
+  prefix?: string;
+  context?: LogContext;
+}
+
+const LOG_LEVELS: Record<LogLevel, number> = {
+  debug: 0,
+  info: 1,
+  warn: 2,
+  error: 3,
+  silent: 4,
+};
+
+const LOG_COLORS: Record<Exclude<LogLevel, 'silent'>, string> = {
+  debug: '\x1b[36m', // cyan
+  info: '\x1b[32m', // green
+  warn: '\x1b[33m', // yellow
+  error: '\x1b[31m', // red
+};
+
+const RESET = '\x1b[0m';
+const DIM = '\x1b[2m';
+const BOLD = '\x1b[1m';
+
+export class Logger {
+  private level: LogLevel;
+  private prefix: string;
+  private showTimestamp: boolean;
+  private useColors: boolean;
+  private jsonOutput: boolean;
+
+  constructor(options: LoggerOptions = {}) {
+    this.level = options.level ?? 'info';
+    this.prefix = options.prefix ?? '';
+    this.showTimestamp = options.timestamp ?? true;
+    this.useColors = options.colors ?? true;
+    this.jsonOutput = options.json ?? false;
+  }
+
+  private shouldLog(level: LogLevel): boolean {
+    return LOG_LEVELS[level] >= LOG_LEVELS[this.level];
+  }
+
+  private formatJson(entry: LogEntry): string {
+    return JSON.stringify(entry);
+  }
+
+  private formatPretty(level: Exclude<LogLevel, 'silent'>, message: string): string {
+    const parts: string[] = [];
+
+    if (this.showTimestamp) {
+      const time = new Date().toISOString();
+      parts.push(this.useColors ? `${DIM}[${time}]${RESET}` : `[${time}]`);
+    }
+
+    const levelTag = `[${level.toUpperCase()}]`;
+    if (this.useColors) {
+      parts.push(`${LOG_COLORS[level]}${BOLD}${levelTag}${RESET}`);
+    } else {
+      parts.push(levelTag);
+    }
+
+    if (this.prefix) {
+      parts.push(this.useColors ? `${DIM}[${this.prefix}]${RESET}` : `[${this.prefix}]`);
+    }
+
+    parts.push(message);
+
+    return parts.join(' ');
+  }
+
+  private log(level: Exclude<LogLevel, 'silent'>, message: string, context?: LogContext): void {
+    if (!this.shouldLog(level)) return;
+
+    const consoleMethod =
+      level === 'debug' ? 'debug' : level === 'info' ? 'info' : level === 'warn' ? 'warn' : 'error';
+
+    if (this.jsonOutput) {
+      const entry: LogEntry = {
+        timestamp: new Date().toISOString(),
+        level,
+        message,
+        ...(this.prefix && { prefix: this.prefix }),
+        ...(context && { context }),
+      };
+      // eslint-disable-next-line no-console
+      console[consoleMethod](this.formatJson(entry));
+    } else {
+      const formatted = this.formatPretty(level, message);
+      if (context) {
+        // eslint-disable-next-line no-console
+        console[consoleMethod](formatted, context);
+      } else {
+        // eslint-disable-next-line no-console
+        console[consoleMethod](formatted);
+      }
+    }
+  }
+
+  debug(message: string, context?: LogContext): void {
+    this.log('debug', message, context);
+  }
+
+  info(message: string, context?: LogContext): void {
+    this.log('info', message, context);
+  }
+
+  warn(message: string, context?: LogContext): void {
+    this.log('warn', message, context);
+  }
+
+  error(message: string, context?: LogContext): void {
+    this.log('error', message, context);
+  }
+
+  child(prefix: string): Logger {
+    return new Logger({
+      level: this.level,
+      prefix: this.prefix ? `${this.prefix}:${prefix}` : prefix,
+      timestamp: this.showTimestamp,
+      colors: this.useColors,
+      json: this.jsonOutput,
+    });
+  }
+
+  setLevel(level: LogLevel): void {
+    this.level = level;
+  }
+
+  getLevel(): LogLevel {
+    return this.level;
+  }
+
+  isLevelEnabled(level: LogLevel): boolean {
+    return this.shouldLog(level);
+  }
+
+  time(label: string): () => void {
+    const start = performance.now();
+    return () => {
+      const duration = performance.now() - start;
+      this.debug(`${label} completed`, { durationMs: Math.round(duration * 100) / 100 });
+    };
+  }
+
+  async timeAsync<T>(label: string, fn: () => Promise<T>): Promise<T> {
+    const end = this.time(label);
+    try {
+      return await fn();
+    } finally {
+      end();
+    }
+  }
+
+  group(label: string): void {
+    if (!this.shouldLog('debug')) return;
+    // eslint-disable-next-line no-console, @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access
+    console.group(this.formatPretty('debug', label));
+  }
+
+  groupEnd(): void {
+    if (!this.shouldLog('debug')) return;
+    // eslint-disable-next-line no-console, @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access
+    console.groupEnd();
+  }
+
+  table(data: unknown): void {
+    if (!this.shouldLog('debug')) return;
+    // eslint-disable-next-line no-console, @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access
+    console.table(data);
+  }
+}
+
+// Default logger instance
+export const logger = new Logger();
+
+// Factory function
+export function createLogger(options: LoggerOptions = {}): Logger {
+  return new Logger(options);
+}

package/templates/default/packages/logger/tsconfig.json

@@ -0,0 +1,11 @@
+{
+  "extends": "../config/typescript/base.json",
+  "compilerOptions": {
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "lib": ["ES2022"],
+    "types": ["node"]
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}

package/templates/default/packages/logger/tsup.config.ts

@@ -0,0 +1,9 @@
+import { defineConfig } from 'tsup';
+
+export default defineConfig({
+  entry: ['src/index.ts'],
+  format: ['cjs', 'esm'],
+  dts: true,
+  clean: true,
+  sourcemap: true,
+});

package/templates/default/packages/result/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "@repo/result",
+  "version": "0.0.0",
+  "private": true,
+  "main": "./dist/index.js",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "lint": "eslint src/",
+    "lint:fix": "eslint src/ --fix",
+    "typecheck": "tsc --noEmit"
+  },
+  "devDependencies": {
+    "tsup": "^8.0.0",
+    "typescript": "^5.4.0"
+  }
+}