@vertz/core 0.1.0 → 0.2.0

package/dist/index.js

@@ -77,7 +77,35 @@ function applyCorsHeaders(config, request, response) {
   });
 }
 
+// src/result.ts
+var RESULT_BRAND = Symbol.for("vertz.result");
+function ok(data) {
+  return { ok: true, data, [RESULT_BRAND]: true };
+}
+function err(status, body) {
+  return { ok: false, status, body, [RESULT_BRAND]: true };
+}
+function isOk(result) {
+  return result.ok === true;
+}
+function isErr(result) {
+  return result.ok === false;
+}
+function isResult(value) {
+  if (value === null || typeof value !== "object")
+    return false;
+  const obj = value;
+  return obj[RESULT_BRAND] === true;
+}
+
 // 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);
@@ -90,10 +118,20 @@ function validateSchema(schema, value, label) {
 }
 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.success) {
+            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 +161,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);
       }
@@ -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,6 +242,43 @@ function buildHandler(config, registrations, globalMiddlewares) {
         env: {}
       });
       const result = await entry.handler(ctx);
+      if (isResult(result)) {
+        if (isOk(result)) {
+          const data = result.data;
+          if (config.validateResponses && entry.responseSchema) {
+            try {
+              entry.responseSchema.parse(data);
+            } catch (error) {
+              const message = error instanceof Error ? 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) {
+              try {
+                errorSchema.parse(errorBody);
+              } catch (error) {
+                const message = error instanceof Error ? `Error schema validation failed for status ${errorStatus}: ${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) {
+        try {
+          entry.responseSchema.parse(result);
+        } catch (error) {
+          const message = error instanceof Error ? error.message : "Response schema validation failed";
+          console.warn(`[vertz] Response validation warning: ${message}`);
+        }
+      }
       const response = result === undefined ? new Response(null, { status: 204 }) : createJsonResponse(result);
       if (config.cors) {
         return applyCorsHeaders(config.cors, request, response);
@@ -234,19 +322,64 @@ 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 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,11 +388,36 @@ 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 routes = collectRoutes(config.basePath ?? "", registrations);
+        const url = `http://${serverHandle.hostname}:${serverHandle.port}`;
+        console.log(formatRouteLog(url, routes));
+      }
+      return serverHandle;
     }
   };
+  if (config.domains && config.domains.length > 0) {
+    const rawPrefix = config.apiPrefix === undefined ? "/api/" : config.apiPrefix;
+    for (const domain of config.domains) {
+      const domainPath = rawPrefix === "" ? "/" + domain.name : (rawPrefix.endsWith("/") ? rawPrefix : rawPrefix + "/") + domain.name;
+      registeredRoutes.push({ method: "GET", path: domainPath });
+      registeredRoutes.push({ method: "GET", path: `${domainPath}/:id` });
+      registeredRoutes.push({ method: "POST", path: domainPath });
+      registeredRoutes.push({ method: "PUT", path: `${domainPath}/:id` });
+      registeredRoutes.push({ method: "DELETE", path: `${domainPath}/:id` });
+      if (domain.actions) {
+        for (const actionName of Object.keys(domain.actions)) {
+          registeredRoutes.push({ method: "POST", path: `${domainPath}/:id/${actionName}` });
+        }
+      }
+    }
+  }
   return builder;
 }
 // src/env/env-validator.ts
@@ -336,23 +494,36 @@ 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,
+  ok,
   makeImmutable,
+  isOk,
+  isErr,
+  err,
   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/package.json

@@ -1,8 +1,9 @@
 {
   "name": "@vertz/core",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "type": "module",
   "license": "MIT",
+  "description": "Vertz core framework primitives",
   "repository": {
     "type": "git",
     "url": "https://github.com/vertz-dev/vertz.git",
@@ -38,11 +39,13 @@
   },
   "devDependencies": {
     "@types/node": "^22.0.0",
+    "@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
 }