@rpal/cli 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 paljs
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/cli/src/index.js

@@ -0,0 +1,55 @@
+#!/usr/bin/env node
+import { Pal } from '@paljs/core';
+console.log(`
+╔═══════════════════════════════════════════╗
+║                                           ║
+║   ██████╗ ███████╗██╗   ██╗███████╗     ║
+║   ██╔══██╗██╔════╝██║   ██║██╔════╝     ║
+║   ██║  ██║█████╗  ██║   ██║█████╗       ║
+║   ██║  ██║██╔══╝  ╚██╗ ██╔╝██╔══╝       ║
+║   ██████╔╝███████╗ ╚████╔╝ ███████╗     ║
+║   ╚═════╝ ╚══════╝  ╚═══╝  ╚══════╝     ║
+║                                           ║
+║   CLI Tool v${require('../package.json').version}                  ║
+║                                           ║
+╚═══════════════════════════════════════════╝
+`);
+const commands = process.argv.slice(2);
+if (commands.length === 0) {
+    console.log(`
+Usage: pal <command>
+
+Commands:
+  init        Initialize a new Pal project
+  generate    Generate code from templates
+  serve       Start development server
+  build       Build for production
+  test        Run tests
+
+Examples:
+  pal init my-project
+  pal generate service User
+  pal serve
+`);
+    process.exit(0);
+}
+const [command, ...args] = commands;
+switch (command) {
+    case 'init':
+        console.log('📦 Initializing Pal project...');
+        console.log('   This would scaffold a new project');
+        break;
+    case 'generate':
+        console.log('🔧 Generating code...');
+        console.log(`   Template: ${args[0] || 'unknown'}`);
+        console.log(`   Name: ${args[1] || 'unnamed'}`);
+        break;
+    case 'serve':
+        console.log('🚀 Starting development server...');
+        const container = Pal.create();
+        console.log('   Container created:', container.constructor.name);
+        break;
+    default:
+        console.log(`❌ Unknown command: ${command}`);
+        process.exit(1);
+}

package/dist/core/src/container.js

@@ -0,0 +1,125 @@
+import 'reflect-metadata';
+import { Scope, DEFAULT_SCOPE } from './scope';
+import { InjectionToken } from './token';
+import { getInjectableMetadata, getConstructorParams } from './decorators';
+export class PalCircularDependencyError extends Error {
+    constructor(path) {
+        super(`Circular dependency detected: ${path}`);
+        this.name = 'PalCircularDependencyError';
+    }
+}
+export class PalDependencyNotFoundError extends Error {
+    constructor(token, index, target) {
+        super(`Cannot resolve dependency "${getTokenName(token)}" at index ${index} in ${target.name || 'Unknown'} constructor`);
+        this.name = 'PalDependencyNotFoundError';
+    }
+}
+function getTokenName(token) {
+    if (token instanceof InjectionToken)
+        return token.name;
+    if (typeof token === 'string')
+        return token;
+    if (typeof token === 'symbol')
+        return String(token);
+    return token.name || 'Unknown';
+}
+export class PalContainer {
+    constructor(parent) {
+        this.registrations = new Map();
+        this.resolutionStack = [];
+        this.singletonCache = new Map();
+        this.parent = parent;
+    }
+    provide(token, provider) {
+        const reg = this.createRegistration(token, provider);
+        this.registrations.set(token, reg);
+        return this;
+    }
+    createRegistration(token, provider) {
+        const scope = provider.scope ?? DEFAULT_SCOPE;
+        if ('useValue' in provider) {
+            return { token, factory: () => provider.useValue, scope: Scope.Singleton, instance: provider.useValue };
+        }
+        if ('useClass' in provider) {
+            return { token, factory: (ctx) => this.resolveClass(provider.useClass, ctx), scope };
+        }
+        if ('useFactory' in provider) {
+            return { token, factory: (ctx) => provider.useFactory(ctx), scope };
+        }
+        throw new Error('Provider must have useValue, useClass, or useFactory');
+    }
+    get(token) {
+        if (this.resolutionStack.includes(token)) {
+            const path = [...this.resolutionStack, token].map(getTokenName).join(' -> ');
+            throw new PalCircularDependencyError(path);
+        }
+        const registration = this.findRegistration(token);
+        if (!registration) {
+            if (token instanceof Function && getInjectableMetadata(token)) {
+                return this.resolveClass(token, this);
+            }
+            throw new PalDependencyNotFoundError(token, 0, token);
+        }
+        return this.resolve(registration);
+    }
+    has(token) {
+        return this.findRegistration(token) !== undefined;
+    }
+    createChild() {
+        return new PalContainer(this);
+    }
+    override(token, provider) {
+        this.registrations.set(token, this.createRegistration(token, provider));
+        return this;
+    }
+    reset() {
+        this.registrations.clear();
+        this.singletonCache.clear();
+    }
+    findRegistration(token) {
+        return this.registrations.get(token) ?? this.parent?.findRegistration(token);
+    }
+    resolve(registration) {
+        if (registration.scope === Scope.Singleton && registration.instance !== undefined) {
+            return registration.instance;
+        }
+        if (registration.scope === Scope.Singleton) {
+            const instance = registration.factory(this);
+            registration.instance = instance;
+            return instance;
+        }
+        return registration.factory(this);
+    }
+    resolveClass(klass, ctx) {
+        this.resolutionStack.push(klass);
+        try {
+            const paramMeta = getConstructorParams(klass);
+            const args = paramMeta.map((param) => {
+                if (param.token && ctx.has(param.token)) {
+                    return param.optional && !ctx.has(param.token) ? undefined : ctx.get(param.token);
+                }
+                if (ctx.has(param.type)) {
+                    return ctx.get(param.type);
+                }
+                if (param.type === Object)
+                    return undefined;
+                try {
+                    return this.resolveClass(param.type, ctx);
+                }
+                catch {
+                    return undefined;
+                }
+            });
+            return new klass(...args);
+        }
+        finally {
+            this.resolutionStack.pop();
+        }
+    }
+}
+export function createPal(parent) {
+    return new PalContainer(parent);
+}
+export const Pal = {
+    create: createPal,
+};

package/dist/core/src/decorators.js

@@ -0,0 +1,59 @@
+import 'reflect-metadata';
+import { DEFAULT_SCOPE } from './scope';
+import { INJECTABLE_METADATA_KEY, INJECTABLE_CONSTRUCTOR_KEY } from './interface';
+const paramsCache = new WeakMap();
+export function Injectable(options) {
+    return (target) => {
+        Reflect.defineMetadata(INJECTABLE_METADATA_KEY, {
+            scope: options?.scope ?? DEFAULT_SCOPE,
+            token: options?.token,
+        }, target);
+    };
+}
+export function Inject(token, type, opts = {}) {
+    return (target, _key, index) => {
+        const inferredType = type || getParamType(target, index);
+        if (!inferredType) {
+            console.warn(`@Inject: Could not determine type for parameter ${index}. Provide it explicitly.`);
+        }
+        storeParamMeta(target, index, { type: inferredType, token, optional: opts.optional });
+    };
+}
+export function Optional() {
+    return (target, _key, index) => {
+        const type = getParamType(target, index);
+        const existing = getParamMeta(target, index);
+        storeParamMeta(target, index, { type, optional: true, token: existing?.token });
+    };
+}
+function getParamType(target, index) {
+    const paramTypes = Reflect.getMetadata('design:paramtypes', target) || [];
+    return paramTypes[index];
+}
+function getParamMeta(target, index) {
+    const params = getConstructorParams(target);
+    return params[index];
+}
+function storeParamMeta(target, index, meta) {
+    const params = Reflect.getOwnMetadata(INJECTABLE_CONSTRUCTOR_KEY, target) || [];
+    params[index] = meta;
+    Reflect.defineMetadata(INJECTABLE_CONSTRUCTOR_KEY, params, target);
+}
+export function getInjectableMetadata(target) {
+    return Reflect.getOwnMetadata(INJECTABLE_METADATA_KEY, target);
+}
+export function getConstructorParams(target) {
+    const cached = paramsCache.get(target);
+    if (cached)
+        return cached;
+    const params = Reflect.getOwnMetadata(INJECTABLE_CONSTRUCTOR_KEY, target) || [];
+    if (!params.length) {
+        const paramTypes = Reflect.getMetadata('design:paramtypes', target) || [];
+        return paramTypes.map((type, index) => ({ type }));
+    }
+    paramsCache.set(target, params);
+    return params;
+}
+export function getInjectionMetadata(target) {
+    return getConstructorParams(target).map(p => ({ token: p.token || p.type, optional: p.optional }));
+}

package/dist/core/src/index.js

@@ -0,0 +1,14 @@
+export * from './scope';
+export * from './token';
+export * from './decorators';
+export * from './interface';
+export * from './container';
+export * from './test-container';
+import { Pal, PalContainer, createPal, PalCircularDependencyError, PalDependencyNotFoundError } from './container';
+import { PalTestContainer } from './test-container';
+export { Pal as default };
+export const Container = PalContainer;
+export const TestContainer = PalTestContainer;
+export const createContainer = createPal;
+export const CircularDependencyError = PalCircularDependencyError;
+export const DependencyNotFoundError = PalDependencyNotFoundError;

package/dist/core/src/interface.js

@@ -0,0 +1,3 @@
+export const INJECTABLE_METADATA_KEY = Symbol('injectable:metadata');
+export const INJECT_METADATA_KEY = Symbol('inject:metadata');
+export const INJECTABLE_CONSTRUCTOR_KEY = Symbol('injectable:constructor');

package/dist/core/src/scope.js

@@ -0,0 +1,6 @@
+export const Scope = {
+    Singleton: 'singleton',
+    Transient: 'transient',
+    Scoped: 'scoped',
+};
+export const DEFAULT_SCOPE = Scope.Singleton;

package/dist/core/src/test-container.js

@@ -0,0 +1,52 @@
+import { PalContainer } from './container';
+export class PalTestContainer extends PalContainer {
+    constructor() {
+        super(...arguments);
+        this.snapshots = [];
+    }
+    static create() {
+        return new PalTestContainer();
+    }
+    snapshot() {
+        this.snapshots.push({
+            registrations: new Map(this.getRegistrations()),
+            singletons: new Map(this.getSingletons()),
+        });
+    }
+    restore() {
+        const snap = this.snapshots.pop();
+        if (!snap)
+            return;
+        this.restoreFrom(snap);
+    }
+    reset() {
+        super.reset();
+        this.snapshots = [];
+    }
+    clearSnapshots() {
+        this.snapshots = [];
+    }
+    mock(token, mockValue) {
+        const mock = new Proxy({}, {
+            get(_, prop) {
+                if (prop === 'then' || prop === 'catch')
+                    return undefined;
+                if (typeof prop === 'symbol')
+                    return undefined;
+                return mockValue?.[prop] ?? (() => mock);
+            },
+        });
+        this.override(token, { useValue: mock });
+        return mock;
+    }
+    getRegistrations() {
+        return this.registrations;
+    }
+    getSingletons() {
+        return this.singletonCache;
+    }
+    restoreFrom(snap) {
+        this.registrations = snap.registrations;
+        this.singletonCache = snap.singletons;
+    }
+}

package/dist/core/src/token.js

@@ -0,0 +1,6 @@
+export class InjectionToken {
+    constructor(name) {
+        this.name = name;
+        this.toString = () => `InjectionToken(${name})`;
+    }
+}

package/dist/index.js

@@ -0,0 +1,468 @@
+#!/usr/bin/env node
+import * as fs from 'fs';
+import * as path from 'path';
+const VERSION = '1.0.0';
+console.log(`
+╔═══════════════════════════════════════════╗
+║                                           ║
+║   ██████╗ ███████╗██╗   ██╗███████╗     ║
+║   ██╔══██╗██╔════╝██║   ██║██╔════╝     ║
+║   ██║  ██║█████╗  ██║   ██║█████╗       ║
+║   ██║  ██║██╔══╝  ╚██╗ ██╔╝██╔══╝       ║
+║   ██████╔╝███████╗ ╚████╔╝ ███████╗     ║
+║   ╚═════╝ ╚══════╝  ╚═══╝  ╚══════╝     ║
+║                                           ║
+║   CLI Tool v${VERSION}                         ║
+║                                           ║
+╚═══════════════════════════════════════════╝
+`);
+const args = process.argv.slice(2);
+const command = args[0];
+if (!command || command === 'help') {
+    showHelp();
+    process.exit(0);
+}
+switch (command) {
+    case 'make:model':
+        makeModel(args.slice(1));
+        break;
+    case 'make:repository':
+        makeRepository(args.slice(1));
+        break;
+    case 'make:service':
+        makeService(args.slice(1));
+        break;
+    case 'make:migration':
+        makeMigration(args.slice(1));
+        break;
+    case 'make:controller':
+        makeController(args.slice(1));
+        break;
+    case 'make:factory':
+        makeFactory(args.slice(1));
+        break;
+    case 'init':
+        initProject(args.slice(1));
+        break;
+    case 'db:push':
+        dbPush();
+        break;
+    case 'db:seed':
+        dbSeed();
+        break;
+    default:
+        console.log(`❌ Unknown command: ${command}`);
+        console.log(`   Run 'pal help' for available commands`);
+        process.exit(1);
+}
+function showHelp() {
+    console.log(`
+Usage: pal <command> [options]
+
+Make Commands:
+  make:model <name>           Create a new model (entity + repository)
+  make:repository <name>       Create a new repository
+  make:service <name>          Create a new service
+  make:controller <name>      Create a new controller
+  make:migration <name>       Create a new migration
+  make:factory <name>          Create a model factory
+
+Database Commands:
+  db:push                      Push schema to database
+  db:seed                      Run database seeds
+
+Project Commands:
+  init [name]                  Initialize a new Pal project
+
+Options:
+  --resource                   Generate CRUD methods (for model/repository/controller)
+  --api                        Generate API-ready controller
+  --force                      Overwrite existing files
+
+Examples:
+  pal make:model User
+  pal make:repository Post --resource
+  pal make:controller UserController --api
+  pal init my-api
+`);
+}
+function makeModel(args) {
+    const name = args[0];
+    if (!name) {
+        console.log('❌ Please provide a model name');
+        console.log('   Example: pal make:model User');
+        process.exit(1);
+    }
+    const options = parseOptions(args);
+    const fileName = toKebabCase(name);
+    const dir = path.join(process.cwd(), 'src', 'models', fileName);
+    ensureDir(dir);
+    const entityCode = generateEntity(name, options);
+    const repositoryCode = generateRepository(name, options);
+    writeFile(path.join(dir, 'index.ts'), entityCode);
+    writeFile(path.join(dir, 'repository.ts'), repositoryCode);
+    console.log(`✅ Created model: src/models/${fileName}/`);
+    console.log(`   - index.ts`);
+    console.log(`   - repository.ts`);
+}
+function makeRepository(args) {
+    const name = args[0];
+    if (!name) {
+        console.log('❌ Please provide a repository name');
+        process.exit(1);
+    }
+    const options = parseOptions(args);
+    const fileName = toKebabCase(name);
+    const dir = path.join(process.cwd(), 'src', 'repositories');
+    ensureDir(dir);
+    const code = generateRepository(name, options);
+    writeFile(path.join(dir, `${fileName}.repository.ts`), code);
+    console.log(`✅ Created repository: src/repositories/${fileName}.repository.ts`);
+}
+function makeService(args) {
+    const name = args[0];
+    if (!name) {
+        console.log('❌ Please provide a service name');
+        process.exit(1);
+    }
+    const fileName = toKebabCase(name);
+    const dir = path.join(process.cwd(), 'src', 'services');
+    ensureDir(dir);
+    const code = generateService(name);
+    writeFile(path.join(dir, `${fileName}.service.ts`), code);
+    console.log(`✅ Created service: src/services/${fileName}.service.ts`);
+}
+function makeController(args) {
+    const name = args[0];
+    if (!name) {
+        console.log('❌ Please provide a controller name');
+        process.exit(1);
+    }
+    const options = parseOptions(args);
+    const fileName = toKebabCase(name);
+    const dir = path.join(process.cwd(), 'src', 'controllers');
+    ensureDir(dir);
+    const code = generateController(name, options);
+    writeFile(path.join(dir, `${fileName}.controller.ts`), code);
+    console.log(`✅ Created controller: src/controllers/${fileName}.controller.ts`);
+}
+function makeMigration(args) {
+    const name = args[0];
+    if (!name) {
+        console.log('❌ Please provide a migration name');
+        process.exit(1);
+    }
+    const timestamp = Date.now();
+    const fileName = `${timestamp}_${toKebabCase(name)}.ts`;
+    const dir = path.join(process.cwd(), 'database', 'migrations');
+    ensureDir(dir);
+    const code = generateMigration(name);
+    writeFile(path.join(dir, fileName), code);
+    console.log(`✅ Created migration: database/migrations/${fileName}`);
+}
+function makeFactory(args) {
+    const name = args[0];
+    if (!name) {
+        console.log('❌ Please provide a factory name');
+        process.exit(1);
+    }
+    const fileName = toKebabCase(name);
+    const dir = path.join(process.cwd(), 'database', 'factories');
+    ensureDir(dir);
+    const code = generateFactory(name);
+    writeFile(path.join(dir, `${fileName}.factory.ts`), code);
+    console.log(`✅ Created factory: database/factories/${fileName}.factory.ts`);
+}
+function initProject(args) {
+    const name = args[0] || 'my-pal-app';
+    console.log(`📦 Initializing Pal project: ${name}...`);
+    const dir = path.join(process.cwd(), name);
+    ensureDir(dir);
+    ensureDir(path.join(dir, 'src', 'models'));
+    ensureDir(path.join(dir, 'src', 'services'));
+    ensureDir(path.join(dir, 'src', 'repositories'));
+    ensureDir(path.join(dir, 'src', 'controllers'));
+    ensureDir(path.join(dir, 'database', 'migrations'));
+    ensureDir(path.join(dir, 'database', 'factories'));
+    ensureDir(path.join(dir, 'tests'));
+    const pkgJson = {
+        name: name,
+        version: '0.0.1',
+        type: 'module',
+        scripts: {
+            dev: 'pal serve',
+            build: 'pal build',
+            test: 'pal test',
+            'db:push': 'pal db:push',
+            'db:seed': 'pal db:seed',
+        },
+        dependencies: {
+            '@paljs/core': 'workspace:*',
+            '@paljs/orm': 'workspace:*',
+            '@paljs/http': 'workspace:*',
+        },
+        devDependencies: {
+            'typescript': '^5.0.0',
+            '@types/node': '^20.0.0',
+            'tsx': '^4.0.0',
+        },
+    };
+    const tsconfig = {
+        compilerOptions: {
+            target: 'ES2022',
+            module: 'ESNext',
+            moduleResolution: 'bundler',
+            experimentalDecorators: true,
+            emitDecoratorMetadata: true,
+            strict: true,
+            esModuleInterop: true,
+            skipLibCheck: true,
+            outDir: 'dist',
+        },
+        include: ['src/**/*'],
+    };
+    writeFile(path.join(dir, 'package.json'), JSON.stringify(pkgJson, null, 2));
+    writeFile(path.join(dir, 'tsconfig.json'), JSON.stringify(tsconfig, null, 2));
+    writeFile(path.join(dir, 'src', 'index.ts'), '// Welcome to Pal!\n\n');
+    console.log(`✅ Project created: ${name}/`);
+    console.log(`   Run: cd ${name} && pnpm install && pnpm dev`);
+}
+function dbPush() {
+    console.log('🔄 Pushing schema to database...');
+    console.log('   (This would sync your models to the database)');
+}
+function dbSeed() {
+    console.log('🌱 Running database seeds...');
+    console.log('   (This would seed your database with initial data)');
+}
+function parseOptions(args) {
+    return args
+        .filter(a => a.startsWith('--'))
+        .reduce((acc, opt) => {
+        acc[opt.slice(2)] = true;
+        return acc;
+    }, {});
+}
+function toKebabCase(str) {
+    return str
+        .replace(/([a-z])([A-Z])/g, '$1-$2')
+        .replace(/[\s_]+/g, '-')
+        .toLowerCase();
+}
+function toCamelCase(str) {
+    return str.charAt(0).toLowerCase() + str.slice(1);
+}
+function ensureDir(dir) {
+    if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+    }
+}
+function writeFile(filePath, content) {
+    if (fs.existsSync(filePath) && !process.argv.includes('--force')) {
+        console.log(`⚠️  File exists: ${filePath}`);
+        console.log(`   Use --force to overwrite`);
+        return;
+    }
+    fs.writeFileSync(filePath, content);
+}
+function generateEntity(name, options) {
+    const camelName = toCamelCase(name);
+    const hasResource = options.resource;
+    return `import { BaseEntity } from '@paljs/orm';
+
+export interface ${name} extends BaseEntity {
+  // Add your fields here
+  name: string;
+  ${hasResource ? `
+  // Common fields for CRUD:
+  // email: string;
+  // status: 'active' | 'inactive';
+  // description?: string;
+  // createdAt: Date;
+  // updatedAt: Date;` : ''}
+}
+
+export interface Create${name}DTO {
+  name: string;
+  ${hasResource ? `// email: string;
+  // status?: 'active' | 'inactive';
+  // description?: string;` : ''}
+}
+
+export interface Update${name}DTO {
+  name?: string;
+  ${hasResource ? `// email?: string;
+  // status?: 'active' | 'inactive';
+  // description?: string;` : ''}
+}
+`;
+}
+function generateRepository(name, options) {
+    const camelName = toCamelCase(name);
+    const hasResource = options.resource;
+    let extraMethods = '';
+    if (hasResource) {
+        extraMethods = `
+  async findByEmail(email: string): Promise<${name} | null> {
+    return this.findOne({ email });
+  }
+
+  async findActive(): Promise<${name}[] | null> {
+    return this.findAll({ status: 'active' });
+  }
+
+  async exists(email: string, excludeId?: string): Promise<boolean> {
+    const existing = await this.findByEmail(email);
+    if (!existing) return false;
+    if (excludeId && existing.id === excludeId) return false;
+    return true;
+  }`;
+    }
+    return `import { BaseRepository } from '@paljs/orm';
+import { ${name}, Create${name}DTO, Update${name}DTO } from './index';
+
+export class ${name}Repository extends BaseRepository<${name}, Create${name}DTO, Update${name}DTO> {
+  protected toEntity(data: Create${name}DTO): ${name} {
+    const now = new Date();
+    return {
+      id: this.generateId(),
+      name: data.name,
+      ${hasResource ? `// email: data.email,
+      // status: data.status || 'active',` : ''}
+      createdAt: now,
+    };
+  }
+
+  protected toUpdateData(data: Update${name}DTO): Partial<${name}> {
+    return {
+      name: data.name,
+      ${hasResource ? `// email: data.email,
+      // status: data.status,
+      // updatedAt: new Date(),` : ''}
+    };
+  }${extraMethods}
+}
+`;
+}
+function generateService(name) {
+    const camelName = toCamelCase(name);
+    const repoName = `${name}Repository`;
+    return `import { Injectable } from '@paljs/core';
+import { ${repoName} } from '../repositories/${toKebabCase(name)}.repository';
+import { Create${name}DTO, Update${name}DTO } from '../models/${toKebabCase(name)}';
+
+@Injectable()
+export class ${name}Service {
+  constructor(private ${camelName}Repo: ${repoName}) {}
+
+  async findAll() {
+    return this.${camelName}Repo.findAll();
+  }
+
+  async findOne(id: string) {
+    return this.${camelName}Repo.findById(id);
+  }
+
+  async create(data: Create${name}DTO) {
+    return this.${camelName}Repo.create(data);
+  }
+
+  async update(id: string, data: Update${name}DTO) {
+    return this.${camelName}Repo.update(id, data);
+  }
+
+  async delete(id: string) {
+    return this.${camelName}Repo.delete(id);
+  }
+}
+`;
+}
+function generateController(name, options) {
+    const camelName = toCamelCase(name);
+    const hasApi = options.api;
+    const hasResource = options.resource;
+    const kebabName = toKebabCase(name);
+    let crudMethods = '';
+    if (hasApi) {
+        crudMethods = `
+  async index() {
+    const ${camelName}s = await this.${camelName}Service.findAll();
+    return { data: ${camelName}s };
+  }
+
+  async show(id: string) {
+    const ${camelName} = await this.${camelName}Service.findOne(id);
+    if (!${camelName}) {
+      throw new Error('${name} not found');
+    }
+    return { data: ${camelName} };
+  }
+
+  async store(data: any) {
+    const ${camelName} = await this.${camelName}Service.create(data);
+    return { data: ${camelName}, status: 201 };
+  }
+
+  async update(id: string, data: any) {
+    const ${camelName} = await this.${camelName}Service.update(id, data);
+    return { data: ${camelName} };
+  }
+
+  async destroy(id: string) {
+    await this.${camelName}Service.delete(id);
+    return { status: 204 };
+  }`;
+    }
+    if (hasResource || hasApi) {
+        return `import { Injectable } from '@paljs/core';
+import { ${name}Service } from '../services/${kebabName}.service';
+
+@Injectable()
+export class ${name}Controller {
+  constructor(private ${camelName}Service: ${name}Service) {} ${crudMethods}
+}
+`;
+    }
+    return `import { Injectable } from '@paljs/core';
+
+@Injectable()
+export class ${name}Controller {
+  async index() {
+    return { data: [] };
+  }
+}
+`;
+}
+function generateMigration(name) {
+    const tableName = toKebabCase(name) + 's';
+    return `import { Migration } from '@paljs/orm';
+
+export class Create${name}Table implements Migration {
+  up() {
+    return \`
+      CREATE TABLE ${tableName} (
+        id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+        name VARCHAR(255) NOT NULL,
+        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+        updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+      )
+    \`;
+  }
+
+  down() {
+    return \`DROP TABLE ${tableName}\`;
+  }
+}
+`;
+}
+function generateFactory(name) {
+    return `import { Factory } from '@paljs/test';
+import { ${name} } from '../models/${toKebabCase(name)}';
+
+export const ${name}Factory = Factory.define<${name}>(({ sequence }) => ({
+  id: \`seed-\${sequence}\`,
+  name: \`Test ${name} \${sequence}\`,
+  createdAt: new Date(),
+}));
+`;
+}

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "@rpal/cli",
+  "version": "1.0.0",
+  "description": "CLI tool for PalJS",
+  "license": "MIT",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "bin": {
+    "pal": "dist/index.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/paljs/paljs.git"
+  },
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "@rpal/core": "^1.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "tsx": "^4.0.0"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "dev": "tsx src/index.ts"
+  }
+}