@kanjijs/cli 0.2.0-beta.2 → 0.2.0-beta.20

package/README.md

@@ -15,6 +15,7 @@ bunx @kanjijs/cli <command>
 ## Commands
 
 ### `new <project-name>`
+
 Scaffolds a new Kanjijs project with a predefined directory structure (bun + typescript).
 
 ```bash
@@ -22,22 +23,43 @@ kanjijs new my-app
 ```
 
 Features included out-of-the-box:
-*   **Hono + Bun** set up.
-*   **Observability**: `@kanjijs/logger` (JSON logs) + Request ID propagation.
-*   **Security**: Rate Limiting enabled by default via `@kanjijs/throttler`.
-*   **DI & Decorators**: Ready to use `@Controller` and `@Inject`.
+
+- **Hono + Bun** set up.
+- **Observability**: `@kanjijs/logger` (JSON logs) + Request ID propagation.
+- **Security**: Rate Limiting enabled by default via `@kanjijs/throttler`.
+- **DI & Decorators**: Ready to use `@Controller` and `@Inject`.
 
 ### `g resource <name>`
-Generates a new Resource Module (Controller + Service + Module).
+
+Generates a new Resource Module (Controller + Service + Module + Test).
 
 ```bash
 kanjijs g resource products
+kanjijs g resource products --repository # With Repository Pattern
+```
+
+- scaffolds `products.module.ts`, `products.controller.ts`, `products.service.ts`
+- **Full CRUD**: Generates `findAll`, `findOne`, `create`, `update`, and `remove` endpoints and methods.
+- **Auto-generates** `products.controller.spec.ts` for unit testing with mocks for all CRUD methods.
+- **Auto-updates** `src/app.module.ts` to import the new module! 🚀
+
+### `g schema <name>`
+
+Generates a new Drizzle ORM Table definition.
+
+```bash
+# Default: src/database/schema/users.ts (and updates index.ts)
+kanjijs g schema users
+
+# Co-located: src/modules/users/schemas/users.ts
+kanjijs g schema users --module users
 ```
 
-*   scaffolds `products.module.ts`, `products.controller.ts`, `products.service.ts`
-*   **Auto-updates** `src/app.module.ts` to import the new module! 🚀
+- Creates a `pgTable` with default columns (`id`, `createdAt`, `updatedAt`).
+- **Auto-updates** the central barrel file (`src/database/schema/index.ts`) to export the new schema.
 
 ### `dev`
+
 Starts the development server via Bun in watch mode.
 
 ```bash
@@ -50,24 +72,28 @@ PORT=4000 kanjijs dev
 
 To hack on the CLI itself:
 
-1.  Clone the repo and install dependencies.
-2.  Link the package globally:
+1. Clone the repo and install dependencies.
+2. Link the package globally:
+
     ```bash
     cd packages/cli
     npm link
     ```
-3.  Run the builder in watch mode:
+
+3. Run the builder in watch mode:
+
     ```bash
     bun run watch
     ```
-4.  In another terminal, test your changes:
+
+4. In another terminal, test your changes:
+
     ```bash
     kanjijs g resource users
     ```
 
-
-
 ### `openapi`
+
 Generates an `openapi.json` file by inspecting your application metadata at runtime.
 
 ```bash
@@ -75,6 +101,7 @@ kanjijs openapi --out openapi.json
 ```
 
 ### `client`
+
 Generates a Type-Safe Client SDK (TypeScript) from your `openapi.json`.
 Uses [openapi-typescript-codegen](https://github.com/ferdikoomen/openapi-typescript-codegen).
 

package/dist/cli/src/commands/base.d.ts

@@ -0,0 +1,4 @@
+import { Command as CommanderCommand } from "commander";
+export declare abstract class Command {
+    abstract load(program: CommanderCommand): void;
+}

package/dist/cli/src/commands/client.command.d.ts

@@ -0,0 +1,5 @@
+import { Command } from "commander";
+import { Command as BaseCommand } from "./base";
+export declare class ClientCommand extends BaseCommand {
+    load(program: Command): void;
+}

package/dist/cli/src/commands/dev.command.d.ts

@@ -0,0 +1,5 @@
+import { Command } from "commander";
+import { Command as BaseCommand } from "./base";
+export declare class DevCommand extends BaseCommand {
+    load(program: Command): void;
+}

package/dist/cli/src/commands/generate.command.d.ts

@@ -0,0 +1,5 @@
+import { Command } from "commander";
+import { Command as BaseCommand } from "./base";
+export declare class GenerateCommand extends BaseCommand {
+    load(program: Command): void;
+}

package/dist/cli/src/commands/new.command.d.ts

@@ -0,0 +1,5 @@
+import { Command } from "commander";
+import { Command as BaseCommand } from "./base";
+export declare class NewCommand extends BaseCommand {
+    load(program: Command): void;
+}

package/dist/cli/src/commands/openapi.command.d.ts

@@ -0,0 +1,5 @@
+import { Command } from "commander";
+import { Command as BaseCommand } from "./base";
+export declare class OpenApiCommand extends BaseCommand {
+    load(program: Command): void;
+}

package/dist/cli/src/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env bun
+export {};

package/dist/commands/base.d.ts

@@ -0,0 +1,4 @@
+import { Command as CommanderCommand } from "commander";
+export declare abstract class Command {
+    abstract load(program: CommanderCommand): void;
+}

package/dist/commands/client.command.d.ts

@@ -0,0 +1,5 @@
+import { Command } from "commander";
+import { Command as BaseCommand } from "./base";
+export declare class ClientCommand extends BaseCommand {
+    load(program: Command): void;
+}

package/dist/commands/dev.command.d.ts

@@ -0,0 +1,5 @@
+import { Command } from "commander";
+import { Command as BaseCommand } from "./base";
+export declare class DevCommand extends BaseCommand {
+    load(program: Command): void;
+}

package/dist/commands/generate.command.d.ts

@@ -0,0 +1,5 @@
+import { Command } from "commander";
+import { Command as BaseCommand } from "./base";
+export declare class GenerateCommand extends BaseCommand {
+    load(program: Command): void;
+}

package/dist/commands/new.command.d.ts

@@ -0,0 +1,5 @@
+import { Command } from "commander";
+import { Command as BaseCommand } from "./base";
+export declare class NewCommand extends BaseCommand {
+    load(program: Command): void;
+}

package/dist/commands/openapi.command.d.ts

@@ -0,0 +1,5 @@
+import { Command } from "commander";
+import { Command as BaseCommand } from "./base";
+export declare class OpenApiCommand extends BaseCommand {
+    load(program: Command): void;
+}

package/dist/contracts/src/index.d.ts

@@ -0,0 +1,27 @@
+export type SchemaLike = unknown;
+export interface ContractRequestSpec<T = SchemaLike> {
+    params?: T;
+    query?: T;
+    headers?: T;
+    cookies?: T;
+    body?: T;
+}
+export interface ContractResponseSpec<T = SchemaLike> {
+    [status: number]: T;
+}
+export interface ContractSpec<T = SchemaLike> {
+    request?: ContractRequestSpec<T>;
+    response?: ContractResponseSpec<T>;
+}
+export interface ValidatorAdapter<S = SchemaLike> {
+    parse<O = unknown>(schema: S, data: unknown): Promise<{
+        success: true;
+        data: O;
+    } | {
+        success: false;
+        issues: unknown[];
+    }>;
+}
+export declare class Contract {
+    static json<T = SchemaLike>(spec: ContractRequestSpec<T>): ContractSpec<T>;
+}

package/dist/core/src/context.d.ts

@@ -0,0 +1,7 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+export interface RequestContext {
+    requestId: string;
+    [key: string]: any;
+}
+export declare const kanjijsContext: AsyncLocalStorage<RequestContext>;
+export declare function getRequestId(): string | undefined;

package/dist/core/src/decorators.d.ts

@@ -0,0 +1,34 @@
+import type { ContractSpec } from "@kanjijs/contracts";
+import { type ModuleMetadata, type Token } from "./metadata";
+/**
+ * @Module({ controllers: [...] })
+ */
+export declare function Module(metadata: ModuleMetadata): ClassDecorator;
+/**
+ * @Contract({ ... })
+ */
+export declare function Contract(spec: ContractSpec): MethodDecorator;
+/**
+ * @Controller('/users')
+ */
+export declare function Controller(prefix?: string): ClassDecorator;
+export declare function Injectable(): ClassDecorator;
+export declare const Get: (path?: string) => MethodDecorator;
+export declare const Post: (path?: string) => MethodDecorator;
+export declare const Put: (path?: string) => MethodDecorator;
+export declare const Delete: (path?: string) => MethodDecorator;
+export declare const Patch: (path?: string) => MethodDecorator;
+/**
+ * @Inject("DATABASE_CLIENT")
+ */
+export declare function Inject(token: Token<unknown>): ParameterDecorator;
+/**
+ * @Use(middleware1, middleware2)
+ * Attaches middlewares to a controller or method.
+ */
+export declare function Use(...middlewares: unknown[]): MethodDecorator & ClassDecorator;
+export declare const Body: (data?: string) => ParameterDecorator;
+export declare const Query: (data?: string) => ParameterDecorator;
+export declare const Param: (data?: string) => ParameterDecorator;
+export declare const Headers: (data?: string) => ParameterDecorator;
+export declare const Ctx: (data?: string) => ParameterDecorator;

package/dist/core/src/di/container.d.ts

@@ -0,0 +1,26 @@
+import { type Constructor, type Token } from "../metadata";
+import "reflect-metadata";
+export declare class KanjijsIoC {
+    private static providers;
+    static register<T>(target: Constructor<T>): void;
+    static register<T>(token: Token<T>, provider: {
+        useValue?: T;
+        useClass?: Constructor<T>;
+    }): void;
+    static resolve<T>(target: Token<T>): T;
+    static clear(): void;
+}
+/**
+ * V2 STRICT CONTAINER
+ * Instance-based, no auto-registration, explicit visibility.
+ */
+export declare class Container {
+    private providers;
+    register<T>(token: Token<T>, provider: {
+        useValue?: T;
+        useClass?: Constructor<T>;
+        useFactory?: (...args: unknown[]) => T;
+        inject?: Array<Token<unknown>>;
+    }): void;
+    resolve<T>(token: Token<T>): T;
+}

package/dist/core/src/di/module-compiler.d.ts

@@ -0,0 +1,12 @@
+import { type Constructor } from "../metadata";
+import { Container } from "./container";
+export declare class ModuleCompiler {
+    private nodes;
+    private globalExportedTokens;
+    compile(rootModule: Constructor): Container;
+    private scan;
+    private processProviders;
+    private validate;
+    private checkDependencies;
+    private registerProviders;
+}

package/dist/core/src/exceptions/exception.filter.d.ts

@@ -0,0 +1,3 @@
+export interface ExceptionFilter<T = any, C = any> {
+    catch(exception: T, context: C): void | Promise<void> | any;
+}

package/dist/core/src/exceptions/http.exception.d.ts

@@ -0,0 +1,7 @@
+export declare class HttpException extends Error {
+    readonly response: string | object;
+    readonly status: number;
+    constructor(response: string | object, status: number);
+    getResponse(): string | object;
+    getStatus(): number;
+}

package/dist/core/src/index.d.ts

@@ -0,0 +1,9 @@
+export type { ContractRequestSpec, ContractResponseSpec, ContractSpec, SchemaLike, ValidatorAdapter, } from "@kanjijs/contracts";
+export * from "./context";
+export * from "./decorators";
+export * from "./di/container";
+export * from "./di/module-compiler";
+export * from "./exceptions/exception.filter";
+export * from "./exceptions/http.exception";
+export * from "./metadata";
+export declare const GLOBAL_MIDDLEWARE_TOKEN: unique symbol;

package/dist/core/src/metadata.d.ts

@@ -0,0 +1,64 @@
+import type { ContractSpec } from "@kanjijs/contracts";
+import "reflect-metadata";
+export type Constructor<T = unknown> = new (...args: unknown[]) => T;
+export type HttpMethod = "GET" | "POST" | "PUT" | "DELETE" | "PATCH";
+export type RouteParamType = "BODY" | "QUERY" | "PARAM" | "HEADERS" | "CONTEXT";
+export interface RouteParamMetadata {
+    index: number;
+    type: RouteParamType;
+    data?: string;
+}
+export interface RouteMetadata {
+    method: HttpMethod;
+    path: string;
+    contract?: ContractSpec;
+    middlewares?: unknown[];
+    params?: RouteParamMetadata[];
+}
+export interface ControllerMetadata {
+    prefix: string;
+    middlewares?: unknown[];
+}
+export type Token<T = unknown> = string | symbol | Constructor<T>;
+export type Provider<T = unknown> = Constructor<T> | {
+    provide: Token<T>;
+    useValue: T;
+} | {
+    provide: Token<T>;
+    useClass: Constructor<T>;
+} | {
+    provide: Token<T>;
+    useFactory: (...args: unknown[]) => T | Promise<T>;
+    inject?: Token[];
+};
+export interface DynamicModule {
+    module: Constructor;
+    providers?: Provider[];
+    imports?: Array<Constructor | DynamicModule>;
+    exports?: Token[];
+    global?: boolean;
+}
+export interface ModuleMetadata {
+    controllers?: Constructor[];
+    providers?: Provider[];
+    imports?: Array<Constructor | DynamicModule>;
+    exports?: Token[];
+    global?: boolean;
+}
+export interface IMetadataStorage {
+    addRoute(target: object, methodName: string, meta: RouteMetadata): void;
+    addContract(target: object, methodName: string, contract: ContractSpec): void;
+    addMiddleware(target: object, middleware: unknown, methodName?: string): void;
+    getRoutes(target: object): Map<string, RouteMetadata> | undefined;
+    setController(target: object, meta: ControllerMetadata): void;
+    getController(target: object): ControllerMetadata | undefined;
+    defineModule(target: object, meta: ModuleMetadata): void;
+    getModule(target: object): ModuleMetadata | undefined;
+    addInjection(target: object, index: number, token: Token<unknown>): void;
+    getInjections(target: object): Map<number, Token<unknown>> | undefined;
+    addRouteParam(target: object, methodName: string, param: RouteParamMetadata): void;
+}
+declare global {
+    var KANJI_METADATA_STORAGE: IMetadataStorage | undefined;
+}
+export declare const MetadataStorage: IMetadataStorage;

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env bun
+export {};