@vertz/core 0.1.0 → 0.2.1

package/dist/index.js

@@ -18,7 +18,19 @@ import {
   parseBody,
   parseRequest,
   runMiddlewareChain
-} from "./shared/chunk-c77pg5gx.js";
+} from "./shared/chunk-k596zpc6.js";
+
+// src/result.ts
+var RESULT_BRAND = Symbol.for("vertz.result");
+function isOk(result) {
+  return result.ok === true;
+}
+function isResult(value) {
+  if (value === null || typeof value !== "object")
+    return false;
+  const obj = value;
+  return obj[RESULT_BRAND] === true;
+}
 
 // src/server/cors.ts
 var DEFAULT_METHODS = ["GET", "POST", "PUT", "PATCH", "DELETE", "OPTIONS"];
@@ -78,22 +90,37 @@ function applyCorsHeaders(config, request, response) {
 }
 
 // src/app/app-runner.ts
+function createResponseWithCors(data, status, config, request) {
+  const response = createJsonResponse(data, status);
+  if (config.cors) {
+    return applyCorsHeaders(config.cors, request, response);
+  }
+  return response;
+}
 function validateSchema(schema, value, label) {
-  try {
-    return schema.parse(value);
-  } catch (error) {
-    if (error instanceof BadRequestException)
-      throw error;
-    const message = error instanceof Error ? error.message : `Invalid ${label}`;
+  const result = schema.parse(value);
+  if (!result.ok) {
+    const message = result.error instanceof Error ? result.error.message : `Invalid ${label}`;
     throw new BadRequestException(message);
   }
+  return result.data;
 }
 function resolveServices(registrations) {
   const serviceMap = new Map;
-  for (const { module } of registrations) {
+  for (const { module, options } of registrations) {
     for (const service of module.services) {
       if (!serviceMap.has(service)) {
-        serviceMap.set(service, service.methods({}, undefined));
+        let parsedOptions = {};
+        if (service.options && options) {
+          const parsed = service.options.safeParse(options);
+          if (parsed.ok) {
+            parsedOptions = parsed.data;
+          } else {
+            throw new Error(`Invalid options for service ${service.moduleName}: ${parsed.error.issues.map((i) => i.message).join(", ")}`);
+          }
+        }
+        const env = {};
+        serviceMap.set(service, service.methods({}, undefined, parsedOptions, env));
       }
     }
   }
@@ -123,14 +150,22 @@ function registerRoutes(trie, basePath, registrations, serviceMap) {
       const resolvedServices = resolveRouterServices(router.inject, serviceMap);
       for (const route of router.routes) {
         const fullPath = basePath + router.prefix + route.path;
+        const routeMiddlewares = (route.config.middlewares ?? []).map((mw) => ({
+          name: mw.name,
+          handler: mw.handler,
+          resolvedInject: {}
+        }));
         const entry = {
           handler: route.config.handler,
           options: options ?? {},
           services: resolvedServices,
+          middlewares: routeMiddlewares,
           paramsSchema: route.config.params,
           bodySchema: route.config.body,
           querySchema: route.config.query,
-          headersSchema: route.config.headers
+          headersSchema: route.config.headers,
+          responseSchema: route.config.response,
+          errorsSchema: route.config.errors
         };
         trie.add(route.method, fullPath, entry);
       }
@@ -143,6 +178,17 @@ function buildHandler(config, registrations, globalMiddlewares) {
   const resolvedMiddlewares = resolveMiddlewares(globalMiddlewares);
   const serviceMap = resolveServices(registrations);
   registerRoutes(trie, basePath, registrations, serviceMap);
+  if (config._entityRoutes) {
+    for (const route of config._entityRoutes) {
+      const entry = {
+        handler: route.handler,
+        options: {},
+        services: {},
+        middlewares: []
+      };
+      trie.add(route.method, route.path, entry);
+    }
+  }
   return async (request) => {
     try {
       if (config.cors) {
@@ -155,9 +201,9 @@ function buildHandler(config, registrations, globalMiddlewares) {
       if (!match) {
         const allowed = trie.getAllowedMethods(parsed.path);
         if (allowed.length > 0) {
-          return createJsonResponse({ error: "MethodNotAllowed", message: "Method Not Allowed", statusCode: 405 }, 405, { allow: allowed.join(", ") });
+          return createJsonResponse({ error: { code: "MethodNotAllowed", message: "Method Not Allowed" } }, 405, { allow: allowed.join(", ") });
         }
-        return createJsonResponse({ error: "NotFound", message: "Not Found", statusCode: 404 }, 404);
+        return createJsonResponse({ error: { code: "NotFound", message: "Not Found" } }, 404);
       }
       const body = await parseBody(request);
       const raw = {
@@ -175,6 +221,11 @@ function buildHandler(config, registrations, globalMiddlewares) {
       };
       const middlewareState = await runMiddlewareChain(resolvedMiddlewares, requestCtx);
       const entry = match.handler;
+      if (entry.middlewares.length > 0) {
+        const routeCtx = { ...requestCtx, ...middlewareState };
+        const routeState = await runMiddlewareChain(entry.middlewares, routeCtx);
+        Object.assign(middlewareState, routeState);
+      }
       const validatedParams = entry.paramsSchema ? validateSchema(entry.paramsSchema, match.params, "params") : match.params;
       const validatedBody = entry.bodySchema ? validateSchema(entry.bodySchema, body, "body") : body;
       const validatedQuery = entry.querySchema ? validateSchema(entry.querySchema, parsed.query, "query") : parsed.query;
@@ -191,7 +242,41 @@ function buildHandler(config, registrations, globalMiddlewares) {
         env: {}
       });
       const result = await entry.handler(ctx);
-      const response = result === undefined ? new Response(null, { status: 204 }) : createJsonResponse(result);
+      if (isResult(result)) {
+        if (isOk(result)) {
+          const data = result.data;
+          if (config.validateResponses && entry.responseSchema) {
+            const validation = entry.responseSchema.parse(data);
+            if (!validation.ok) {
+              const message = validation.error instanceof Error ? validation.error.message : "Response schema validation failed";
+              console.warn(`[vertz] Response validation warning: ${message}`);
+            }
+          }
+          return createResponseWithCors(data, 200, config, request);
+        } else {
+          const errorStatus = result.status;
+          const errorBody = result.body;
+          if (config.validateResponses && entry.errorsSchema) {
+            const errorSchema = entry.errorsSchema[errorStatus];
+            if (errorSchema) {
+              const validation = errorSchema.parse(errorBody);
+              if (!validation.ok) {
+                const message = validation.error instanceof Error ? `Error schema validation failed for status ${errorStatus}: ${validation.error.message}` : `Error schema validation failed for status ${errorStatus}`;
+                console.warn(`[vertz] Response validation warning: ${message}`);
+              }
+            }
+          }
+          return createResponseWithCors(errorBody, errorStatus, config, request);
+        }
+      }
+      if (config.validateResponses && entry.responseSchema) {
+        const validation = entry.responseSchema.parse(result);
+        if (!validation.ok) {
+          const message = validation.error instanceof Error ? validation.error.message : "Response schema validation failed";
+          console.warn(`[vertz] Response validation warning: ${message}`);
+        }
+      }
+      const response = result === undefined ? new Response(null, { status: 204 }) : result instanceof Response ? result : createJsonResponse(result);
       if (config.cors) {
         return applyCorsHeaders(config.cors, request, response);
       }
@@ -234,19 +319,65 @@ function detectAdapter(hints) {
   throw new Error("No supported server runtime detected. Vertz requires Bun to use app.listen().");
 }
 
+// src/app/route-log.ts
+function normalizePath(path) {
+  let normalized = path.replace(/\/+/g, "/");
+  if (normalized.length > 1 && normalized.endsWith("/")) {
+    normalized = normalized.slice(0, -1);
+  }
+  return normalized || "/";
+}
+function collectRoutes(basePath, registrations) {
+  const routes = [];
+  for (const { module } of registrations) {
+    for (const router of module.routers) {
+      for (const route of router.routes) {
+        routes.push({
+          method: route.method,
+          path: normalizePath(basePath + router.prefix + route.path)
+        });
+      }
+    }
+  }
+  return routes;
+}
+function formatRouteLog(listenUrl, routes) {
+  const header = `vertz server listening on ${listenUrl}`;
+  if (routes.length === 0) {
+    return header;
+  }
+  const sorted = [...routes].sort((a, b) => a.path.localeCompare(b.path) || a.method.localeCompare(b.method));
+  const MIN_METHOD_WIDTH = 6;
+  const maxMethodLen = Math.max(MIN_METHOD_WIDTH, ...sorted.map((r) => r.method.length));
+  const lines = sorted.map((r) => {
+    const paddedMethod = r.method.padEnd(maxMethodLen);
+    return `  ${paddedMethod} ${r.path}`;
+  });
+  return [header, "", ...lines].join(`
+`);
+}
+
 // src/app/app-builder.ts
 var DEFAULT_PORT = 3000;
 function createApp(config) {
   const registrations = [];
   let globalMiddlewares = [];
   let cachedHandler = null;
+  const registeredRoutes = [];
+  const entityRoutes = [];
   const builder = {
     register(module, options) {
       registrations.push({ module, options });
+      for (const router of module.routers) {
+        for (const route of router.routes) {
+          registeredRoutes.push({ method: route.method, path: router.prefix + route.path });
+        }
+      }
+      cachedHandler = null;
       return builder;
     },
     middlewares(list) {
-      globalMiddlewares = list;
+      globalMiddlewares = [...list];
       return builder;
     },
     get handler() {
@@ -255,17 +386,54 @@ function createApp(config) {
       }
       return cachedHandler;
     },
+    get router() {
+      return { routes: registeredRoutes };
+    },
     async listen(port, options) {
       const adapter = detectAdapter();
-      return adapter.listen(port ?? DEFAULT_PORT, builder.handler, options);
+      const serverHandle = await adapter.listen(port ?? DEFAULT_PORT, builder.handler, options);
+      if (options?.logRoutes !== false) {
+        const moduleRoutes = collectRoutes(config.basePath ?? "", registrations);
+        const routes = [...moduleRoutes, ...entityRoutes];
+        const url = `http://${serverHandle.hostname}:${serverHandle.port}`;
+        console.log(formatRouteLog(url, routes));
+      }
+      return serverHandle;
     }
   };
+  if (config._entityRoutes) {
+    for (const route of config._entityRoutes) {
+      const info = { method: route.method, path: route.path };
+      registeredRoutes.push(info);
+      entityRoutes.push(info);
+    }
+  } else if (config.entities && config.entities.length > 0) {
+    const rawPrefix = config.apiPrefix === undefined ? "/api/" : config.apiPrefix;
+    for (const entity of config.entities) {
+      const entityPath = rawPrefix === "" ? `/${entity.name}` : (rawPrefix.endsWith("/") ? rawPrefix : `${rawPrefix}/`) + entity.name;
+      const routes = [
+        { method: "GET", path: entityPath },
+        { method: "GET", path: `${entityPath}/:id` },
+        { method: "POST", path: entityPath },
+        { method: "PATCH", path: `${entityPath}/:id` },
+        { method: "DELETE", path: `${entityPath}/:id` }
+      ];
+      if (entity.actions) {
+        for (const actionName of Object.keys(entity.actions)) {
+          routes.push({ method: "POST", path: `${entityPath}/:id/${actionName}` });
+        }
+      }
+      registeredRoutes.push(...routes);
+      entityRoutes.push(...routes);
+    }
+  }
   return builder;
 }
 // src/env/env-validator.ts
 function createEnv(config) {
-  const result = config.schema.safeParse(process.env);
-  if (!result.success) {
+  const envRecord = config.env ?? (typeof process !== "undefined" ? process.env : {});
+  const result = config.schema.safeParse(envRecord);
+  if (!result.ok) {
     throw new Error(`Environment validation failed:
 ${result.error.message}`);
   }
@@ -336,23 +504,32 @@ function createModuleDef(config) {
   return deepFreeze(def);
 }
 // src/vertz.ts
-var vertz = deepFreeze({
+var vertz = /* @__PURE__ */ deepFreeze({
   env: createEnv,
   middleware: createMiddleware,
   moduleDef: createModuleDef,
   module: createModule,
-  app: createApp
+  app: createApp,
+  server: createApp
 });
+
+// src/index.ts
+var createServer = createApp;
+var createApp2 = (...args) => {
+  console.warn("⚠️ createApp() is deprecated. Use createServer() from @vertz/server instead.");
+  return createApp(...args);
+};
 export {
   vertz,
   makeImmutable,
   deepFreeze,
+  createServer,
   createModuleDef,
   createModule,
   createMiddleware,
   createImmutableProxy,
   createEnv,
-  createApp,
+  createApp2 as createApp,
   VertzException,
   ValidationException,
   UnauthorizedException,

package/dist/internals.d.ts

@@ -7,7 +7,7 @@ interface RawRequest {
 interface HandlerCtx {
 	params: Record<string, unknown>;
 	body: unknown;
-	query: Record<string, unknown>;
+	query: Record<string, string>;
 	headers: Record<string, unknown>;
 	raw: RawRequest;
 	options: Record<string, unknown>;
@@ -17,7 +17,7 @@ interface HandlerCtx {
 interface CtxConfig {
 	params: Record<string, unknown>;
 	body: unknown;
-	query: Record<string, unknown>;
+	query: Record<string, string>;
 	headers: Record<string, unknown>;
 	raw: RawRequest;
 	middlewareState: Record<string, unknown>;

package/dist/internals.js

@@ -6,7 +6,7 @@ import {
   parseBody,
   parseRequest,
   runMiddlewareChain
-} from "./shared/chunk-c77pg5gx.js";
+} from "./shared/chunk-k596zpc6.js";
 export {
   runMiddlewareChain,
   parseRequest,

package/dist/shared/{chunk-c77pg5gx.js → chunk-k596zpc6.js}

@@ -41,7 +41,7 @@ function deepFreeze(obj, visited = new WeakSet) {
 
 // src/immutability/make-immutable.ts
 function makeImmutable(obj, contextName) {
-  if (true) {
+  if (typeof process !== "undefined" && true) {
     return createImmutableProxy(obj, contextName);
   }
   return obj;
@@ -65,7 +65,7 @@ function validateCollisions(config) {
   }
 }
 function buildCtx(config) {
-  if (true) {
+  if (typeof process !== "undefined" && true) {
     validateCollisions(config);
   }
   return makeImmutable({
@@ -98,11 +98,11 @@ class VertzException extends Error {
   }
   toJSON() {
     return {
-      error: this.name,
-      message: this.message,
-      statusCode: this.statusCode,
-      code: this.code,
-      ...this.details !== undefined && { details: this.details }
+      error: {
+        code: this.code,
+        message: this.message,
+        ...this.details !== undefined && { details: this.details }
+      }
     };
   }
 }
@@ -110,57 +110,60 @@ class VertzException extends Error {
 // src/exceptions/http-exceptions.ts
 class BadRequestException extends VertzException {
   constructor(message, details) {
-    super(message, 400, undefined, details);
+    super(message, 400, "BadRequest", details);
   }
 }
 
 class UnauthorizedException extends VertzException {
   constructor(message, details) {
-    super(message, 401, undefined, details);
+    super(message, 401, "Unauthorized", details);
   }
 }
 
 class ForbiddenException extends VertzException {
   constructor(message, details) {
-    super(message, 403, undefined, details);
+    super(message, 403, "Forbidden", details);
   }
 }
 
 class NotFoundException extends VertzException {
   constructor(message, details) {
-    super(message, 404, undefined, details);
+    super(message, 404, "NotFound", details);
   }
 }
 
 class ConflictException extends VertzException {
   constructor(message, details) {
-    super(message, 409, undefined, details);
+    super(message, 409, "Conflict", details);
   }
 }
 
 class ValidationException extends VertzException {
   errors;
   constructor(errors) {
-    super("Validation failed", 422, undefined, undefined);
+    super("Validation failed", 422, "ValidationError", undefined);
     this.errors = errors;
   }
   toJSON() {
     return {
-      ...super.toJSON(),
-      errors: this.errors
+      error: {
+        code: this.code,
+        message: this.message,
+        details: this.errors
+      }
     };
   }
 }
 
 class InternalServerErrorException extends VertzException {
   constructor(message, details) {
-    super(message, 500, undefined, details);
+    super(message, 500, "InternalError", details);
   }
 }
 
 class ServiceUnavailableException extends VertzException {
   constructor(message, details) {
-    super(message, 503, undefined, details);
+    super(message, 503, "ServiceUnavailable", details);
   }
 }
 // src/middleware/middleware-runner.ts
@@ -334,7 +337,7 @@ function createErrorResponse(error) {
   if (error instanceof VertzException) {
     return createJsonResponse(error.toJSON(), error.statusCode);
   }
-  return createJsonResponse({ error: "InternalServerError", message: "Internal Server Error", statusCode: 500 }, 500);
+  return createJsonResponse({ error: { code: "InternalServerError", message: "Internal Server Error" } }, 500);
 }
 
 export { createImmutableProxy, deepFreeze, makeImmutable, buildCtx, VertzException, BadRequestException, UnauthorizedException, ForbiddenException, NotFoundException, ConflictException, ValidationException, InternalServerErrorException, ServiceUnavailableException, runMiddlewareChain, Trie, parseRequest, parseBody, createJsonResponse, createErrorResponse };

package/package.json

@@ -1,8 +1,9 @@
 {
   "name": "@vertz/core",
-  "version": "0.1.0",
+  "version": "0.2.1",
   "type": "module",
   "license": "MIT",
+  "description": "Vertz core framework primitives",
   "repository": {
     "type": "git",
     "url": "https://github.com/vertz-dev/vertz.git",
@@ -29,20 +30,23 @@
   ],
   "scripts": {
     "build": "bunup",
-    "test": "vitest run",
+    "test": "bun test",
+    "test:coverage": "vitest run --coverage",
     "test:watch": "vitest",
     "typecheck": "tsc --noEmit"
   },
   "dependencies": {
-    "@vertz/schema": "workspace:*"
+    "@vertz/schema": "0.2.1"
   },
   "devDependencies": {
-    "@types/node": "^22.0.0",
+    "@types/node": "^25.3.1",
+    "@vitest/coverage-v8": "^4.0.18",
     "bunup": "latest",
     "typescript": "^5.7.0",
-    "vitest": "^3.0.0"
+    "vitest": "^4.0.18"
   },
   "engines": {
     "node": ">=22"
-  }
+  },
+  "sideEffects": false
 }