@spfn/core 0.1.0-alpha.7 → 0.1.0-alpha.74

package/dist/types-Dzggq1Yb.d.ts

@@ -0,0 +1,170 @@
+import { Context } from 'hono';
+import { ContentfulStatusCode } from 'hono/utils/http-status';
+import * as _sinclair_typebox from '@sinclair/typebox';
+import { TSchema, Static } from '@sinclair/typebox';
+import { b as ErrorResponse } from './error-handler-wjLL3v-a.js';
+
+/**
+ * Success response wrapper
+ */
+interface ApiSuccessResponse<T = any> {
+    success: true;
+    data: T;
+    meta?: {
+        timestamp?: string;
+        requestId?: string;
+        pagination?: {
+            page: number;
+            limit: number;
+            total: number;
+            totalPages: number;
+        };
+        [key: string]: any;
+    };
+}
+/**
+ * Error response type (re-exported from ErrorHandler for consistency)
+ */
+type ApiErrorResponse = ErrorResponse;
+/**
+ * Unified API response type
+ */
+type ApiResponse<T = any> = ApiSuccessResponse<T> | ApiErrorResponse;
+/**
+ * Creates a TypeBox schema for ApiSuccessResponse<T>
+ *
+ * @example
+ * ```ts
+ * const UserSchema = Type.Object({
+ *   id: Type.String(),
+ *   name: Type.String(),
+ * });
+ *
+ * const contract = {
+ *   response: ApiSuccessSchema(UserSchema),
+ * };
+ * ```
+ */
+declare function ApiSuccessSchema<T extends TSchema>(dataSchema: T): _sinclair_typebox.TObject<{
+    success: _sinclair_typebox.TLiteral<true>;
+    data: T;
+    meta: _sinclair_typebox.TOptional<_sinclair_typebox.TObject<{
+        timestamp: _sinclair_typebox.TOptional<_sinclair_typebox.TString>;
+        requestId: _sinclair_typebox.TOptional<_sinclair_typebox.TString>;
+        pagination: _sinclair_typebox.TOptional<_sinclair_typebox.TObject<{
+            page: _sinclair_typebox.TNumber;
+            limit: _sinclair_typebox.TNumber;
+            total: _sinclair_typebox.TNumber;
+            totalPages: _sinclair_typebox.TNumber;
+        }>>;
+    }>>;
+}>;
+/**
+ * Creates a TypeBox schema for ApiErrorResponse
+ */
+declare function ApiErrorSchema(): _sinclair_typebox.TObject<{
+    success: _sinclair_typebox.TLiteral<false>;
+    error: _sinclair_typebox.TObject<{
+        message: _sinclair_typebox.TString;
+        type: _sinclair_typebox.TString;
+        statusCode: _sinclair_typebox.TNumber;
+        stack: _sinclair_typebox.TOptional<_sinclair_typebox.TString>;
+        details: _sinclair_typebox.TOptional<_sinclair_typebox.TAny>;
+    }>;
+}>;
+/**
+ * Creates a TypeBox union schema for ApiResponse<T>
+ *
+ * Use this in your route contract's response field for standardized responses.
+ *
+ * @example
+ * ```ts
+ * const contract = {
+ *   method: 'GET',
+ *   path: '/users/:id',
+ *   response: ApiResponseSchema(Type.Object({
+ *     id: Type.String(),
+ *     name: Type.String(),
+ *   })),
+ * };
+ * ```
+ */
+declare function ApiResponseSchema<T extends TSchema>(dataSchema: T): _sinclair_typebox.TUnion<[_sinclair_typebox.TObject<{
+    success: _sinclair_typebox.TLiteral<true>;
+    data: T;
+    meta: _sinclair_typebox.TOptional<_sinclair_typebox.TObject<{
+        timestamp: _sinclair_typebox.TOptional<_sinclair_typebox.TString>;
+        requestId: _sinclair_typebox.TOptional<_sinclair_typebox.TString>;
+        pagination: _sinclair_typebox.TOptional<_sinclair_typebox.TObject<{
+            page: _sinclair_typebox.TNumber;
+            limit: _sinclair_typebox.TNumber;
+            total: _sinclair_typebox.TNumber;
+            totalPages: _sinclair_typebox.TNumber;
+        }>>;
+    }>>;
+}>, _sinclair_typebox.TObject<{
+    success: _sinclair_typebox.TLiteral<false>;
+    error: _sinclair_typebox.TObject<{
+        message: _sinclair_typebox.TString;
+        type: _sinclair_typebox.TString;
+        statusCode: _sinclair_typebox.TNumber;
+        stack: _sinclair_typebox.TOptional<_sinclair_typebox.TString>;
+        details: _sinclair_typebox.TOptional<_sinclair_typebox.TAny>;
+    }>;
+}>]>;
+
+/**
+ * File-based Routing System Type Definitions
+ */
+type HeaderRecord = Record<string, string | string[]>;
+type RouteMeta = {
+    public?: boolean;
+    skipMiddlewares?: string[];
+    tags?: string[];
+    description?: string;
+    deprecated?: boolean;
+};
+/**
+ * Route Contract: TypeBox-based type-safe route definition
+ *
+ * Defines the shape of request/response for a route endpoint
+ */
+type RouteContract = {
+    method: HttpMethod;
+    path: string;
+    params?: TSchema;
+    query?: TSchema;
+    body?: TSchema;
+    response: TSchema;
+    meta?: RouteMeta;
+};
+/**
+ * Infer types from RouteContract
+ *
+ * Extracts TypeScript types from TypeBox schemas
+ */
+type InferContract<TContract extends RouteContract> = {
+    params: TContract['params'] extends TSchema ? Static<TContract['params']> : Record<string, never>;
+    query: TContract['query'] extends TSchema ? Static<TContract['query']> : Record<string, never>;
+    body: TContract['body'] extends TSchema ? Static<TContract['body']> : Record<string, never>;
+    response: TContract['response'] extends TSchema ? Static<TContract['response']> : unknown;
+};
+/**
+ * RouteContext: Route Handler Dedicated Context
+ *
+ * Generic version with contract-based type inference
+ */
+type RouteContext<TContract extends RouteContract = any> = {
+    params: InferContract<TContract>['params'];
+    query: InferContract<TContract>['query'];
+    data(): Promise<InferContract<TContract>['body']>;
+    json(data: InferContract<TContract>['response'], status?: ContentfulStatusCode, headers?: HeaderRecord): Response;
+    success<T>(data: T, meta?: ApiSuccessResponse<T>['meta'], status?: number): Response;
+    paginated<T>(data: T[], page: number, limit: number, total: number): Response;
+    raw: Context;
+};
+type HttpMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
+type RouteHandler<TContract extends RouteContract = any> = (c: RouteContext<TContract>) => Response | Promise<Response>;
+declare function isHttpMethod(value: unknown): value is HttpMethod;
+
+export { ApiSuccessSchema as A, type HttpMethod as H, type InferContract as I, type RouteContext as R, type RouteContract as a, type RouteHandler as b, ApiErrorSchema as c, ApiResponseSchema as d, type ApiSuccessResponse as e, type ApiErrorResponse as f, type ApiResponse as g, type HeaderRecord as h, isHttpMethod as i, type RouteMeta as j };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@spfn/core",
-  "version": "0.1.0-alpha.7",
+  "version": "0.1.0-alpha.74",
   "description": "SPFN Framework Core - File-based routing, transactions, repository pattern",
   "type": "module",
   "main": "./dist/index.js",
@@ -31,15 +31,45 @@
       "import": "./dist/server/index.js",
       "require": "./dist/server/index.js"
     },
-    "./scripts": {
-      "types": "./dist/scripts/index.d.ts",
-      "import": "./dist/scripts/index.js",
-      "require": "./dist/scripts/index.js"
+    "./errors": {
+      "types": "./dist/errors/index.d.ts",
+      "import": "./dist/errors/index.js",
+      "require": "./dist/errors/index.js"
+    },
+    "./middleware": {
+      "types": "./dist/middleware/index.d.ts",
+      "import": "./dist/middleware/index.js",
+      "require": "./dist/middleware/index.js"
+    },
+    "./cache": {
+      "types": "./dist/cache/index.d.ts",
+      "import": "./dist/cache/index.js",
+      "require": "./dist/cache/index.js"
     },
     "./codegen": {
       "types": "./dist/codegen/index.d.ts",
       "import": "./dist/codegen/index.js",
       "require": "./dist/codegen/index.js"
+    },
+    "./env": {
+      "types": "./dist/env/index.d.ts",
+      "import": "./dist/env/index.js",
+      "require": "./dist/env/index.js"
+    },
+    "./logger": {
+      "types": "./dist/logger/index.d.ts",
+      "import": "./dist/logger/index.js",
+      "require": "./dist/logger/index.js"
+    },
+    "./generators": {
+      "types": "./dist/codegen/generators/index.d.ts",
+      "import": "./dist/codegen/generators/index.js",
+      "require": "./dist/codegen/generators/index.js"
+    },
+    "./codegen/generators": {
+      "types": "./dist/codegen/generators/index.d.ts",
+      "import": "./dist/codegen/generators/index.js",
+      "require": "./dist/codegen/generators/index.js"
     }
   },
   "keywords": [
@@ -89,6 +119,8 @@
     "drizzle-orm": "^0.44.6",
     "drizzle-typebox": "^0.1.0",
     "hono": "^4.9.0",
+    "jiti": "^2.6.1",
+    "micromatch": "^4.0.8",
     "pino": "^10.0.0",
     "postgres": "^3.4.0",
     "typescript": "^5.3.3",
@@ -98,9 +130,12 @@
     "ioredis": "^5.4.1"
   },
   "devDependencies": {
+    "@types/micromatch": "^4.0.9",
     "@types/node": "^20.11.0",
+    "@vitest/coverage-v8": "^4.0.6",
+    "drizzle-kit": "^0.31.5",
     "tsup": "^8.0.0",
-    "vitest": "^3.2.4"
+    "vitest": "^4.0.6"
   },
   "files": [
     "dist",
@@ -114,15 +149,24 @@
   },
   "scripts": {
     "build": "tsup",
-    "dev": "tsup --watch",
+    "dev": "tsup",
     "test": "vitest",
-    "test:codegen": "vitest run --config vitest.codegen.config.ts",
-    "test:db": "dotenv -e .env.test -- vitest src/tests/db",
-    "docker:test:up": "docker compose -f ../../docker-compose.test.yml up -d",
-    "docker:test:down": "docker compose -f ../../docker-compose.test.yml down",
-    "docker:test:logs": "docker compose -f ../../docker-compose.test.yml logs -f",
-    "type-check": "tsc --noEmit",
-    "generate:client": "node dist/scripts/generate-client.js",
-    "generate:client:watch": "node dist/scripts/generate-client.js --watch"
+    "test:unit": "vitest --config vitest.unit.config.ts",
+    "test:integration": "vitest --config vitest.integration.config.ts",
+    "test:coverage": "vitest run --config vitest.unit.config.ts --coverage",
+    "test:logger": "vitest src/logger",
+    "test:errors": "vitest src/errors",
+    "test:codegen": "vitest src/codegen",
+    "test:route": "vitest src/route",
+    "test:client": "vitest src/client",
+    "test:middleware": "vitest src/middleware",
+    "test:env": "vitest src/env",
+    "test:cache": "vitest src/cache --config vitest.integration.config.ts",
+    "test:db": "vitest src/db --config vitest.integration.config.ts",
+    "test:server": "vitest src/server --config vitest.integration.config.ts",
+    "docker:test:up": "docker compose -f docker-compose.test.yml up -d",
+    "docker:test:down": "docker compose -f docker-compose.test.yml down",
+    "docker:test:logs": "docker compose -f docker-compose.test.yml logs -f",
+    "type-check": "tsc --noEmit"
   }
 }

package/dist/auto-loader-C44TcLmM.d.ts

@@ -1,125 +0,0 @@
-import { Hono } from 'hono';
-
-/**
- * Extend Hono Context to support skipMiddlewares metadata
- */
-declare module 'hono' {
-    interface ContextVariableMap {
-        _skipMiddlewares?: string[];
-    }
-}
-/**
- * AutoRouteLoader: Simplified File-based Routing System
- *
- * ## Features
- * - 📁 Auto-discovery: Scans routes directory and auto-registers
- * - 🔄 Dynamic routes: [id] → :id, [...slug] → *
- * - 📊 Statistics: Route registration stats for dashboard
- * - 🏷️ Grouping: Natural grouping by directory structure
- *
- * ## Usage
- * ```typescript
- * const app = new Hono();
- * await loadRoutes(app);
- * ```
- */
-type RouteInfo = {
-    /** URL path (e.g., /users/:id) */
-    path: string;
-    /** File path relative to routes dir */
-    file: string;
-    /** Route metadata from export */
-    meta?: {
-        description?: string;
-        tags?: string[];
-        auth?: boolean;
-        [key: string]: unknown;
-    };
-    /** Priority (1=static, 2=dynamic, 3=catch-all) */
-    priority: number;
-};
-type RouteStats = {
-    total: number;
-    byPriority: {
-        static: number;
-        dynamic: number;
-        catchAll: number;
-    };
-    byTag: Record<string, number>;
-    routes: RouteInfo[];
-};
-declare class AutoRouteLoader {
-    private routesDir;
-    private routes;
-    private registeredRoutes;
-    private debug;
-    private readonly middlewares;
-    constructor(routesDir: string, debug?: boolean, middlewares?: Array<{
-        name: string;
-        handler: any;
-    }>);
-    /**
-     * Load all routes from directory
-     */
-    load(app: Hono): Promise<RouteStats>;
-    /**
-     * Get route statistics
-     */
-    getStats(): RouteStats;
-    /**
-     * Recursively scan directory for .ts files
-     */
-    private scanFiles;
-    /**
-     * Check if file is a valid route file
-     */
-    private isValidRouteFile;
-    /**
-     * Load and register a single route
-     * Returns true if successful, false if failed
-     */
-    private loadRoute;
-    /**
-     * Convert file path to URL path
-     *
-     * Examples:
-     * - users/index.ts → /users
-     * - users/[id].ts → /users/:id
-     * - posts/[...slug].ts → /posts/*
-     */
-    private fileToPath;
-    /**
-     * Calculate route priority
-     * 1 = static, 2 = dynamic, 3 = catch-all
-     */
-    private calculatePriority;
-    /**
-     * Normalize path for conflict detection
-     *
-     * Converts dynamic parameter names to generic placeholders:
-     * - /users/:id → /users/:param
-     * - /users/:userId → /users/:param (conflict!)
-     * - /posts/* → /posts/* (unchanged)
-     *
-     * This allows detection of routes with different param names
-     * that would match the same URL patterns.
-     */
-    private normalizePath;
-    /**
-     * Log statistics
-     */
-    private logStats;
-}
-/**
- * Load routes from default location (src/server/routes)
- */
-declare function loadRoutes(app: Hono, options?: {
-    routesDir?: string;
-    debug?: boolean;
-    middlewares?: Array<{
-        name: string;
-        handler: any;
-    }>;
-}): Promise<RouteStats>;
-
-export { AutoRouteLoader as A, type RouteInfo as R, type RouteStats as a, loadRoutes as l };

package/dist/bind-pssq1NRT.d.ts

@@ -1,34 +0,0 @@
-import { Context } from 'hono';
-import { R as RouteContract, c as RouteContext } from './types-SlzTr8ZO.js';
-
-/**
- * Contract-based Route Handler Wrapper
- *
- * Binds a contract to a route handler, providing automatic validation
- * and type-safe context creation.
- *
- * ## Features
- * - ✅ Automatic params/query/body validation using TypeBox
- * - ✅ Type-safe RouteContext with contract-based inference
- * - ✅ Clean separation: bind() for validation, Hono for middleware
- *
- * ## Usage
- *
- * ```typescript
- * // Basic usage
- * export const GET = bind(contract, async (c) => {
- *     return c.json({ data: 'public' });
- * });
- *
- * // For middleware, use Hono's app-level or route-level middleware:
- * // app.use('/api/*', authMiddleware);
- * // app.get('/users/:id', authMiddleware, bind(contract, handler));
- * ```
- *
- * @param contract - Route contract defining params, query, body, response schemas
- * @param handler - Route handler function
- * @returns Hono-compatible handler function
- */
-declare function bind<TContract extends RouteContract>(contract: TContract, handler: (c: RouteContext<TContract>) => Response | Promise<Response>): (rawContext: Context) => Promise<Response>;
-
-export { bind as b };