@fragno-dev/node 0.0.5

package/.turbo/turbo-build.log

@@ -0,0 +1,13 @@
+$ tsdown
+ℹ tsdown v0.15.5 powered by rolldown v1.0.0-beta.40
+ℹ Using tsdown config: /home/runner/work/fragno/fragno/packages/fragno-node/tsdown.config.ts
+ℹ entry: fragno-node.ts
+ℹ target: node20.0.0
+ℹ tsconfig: tsconfig.json
+ℹ Build start
+ℹ dist/fragno-node.js        1.37 kB │ gzip: 0.50 kB
+ℹ dist/fragno-node.js.map    1.68 kB │ gzip: 0.60 kB
+ℹ dist/fragno-node.d.ts.map  0.20 kB │ gzip: 0.14 kB
+ℹ dist/fragno-node.d.ts      1.40 kB │ gzip: 0.50 kB
+ℹ 4 files, total: 4.64 kB
+✔ Build complete in 10283ms

package/.turbo/turbo-types$colon$check.log

@@ -0,0 +1 @@
+$ tsc --noEmit

package/CHANGELOG.md

@@ -0,0 +1,29 @@
+# @fragno-dev/node
+
+## 0.0.5
+
+### Patch Changes
+
+- Updated dependencies [b9450b1]
+  - @fragno-dev/core@0.0.5
+
+## 0.0.4
+
+### Patch Changes
+
+- Updated dependencies [1dae6f9]
+  - @fragno-dev/core@0.0.4
+
+## 0.0.3
+
+### Patch Changes
+
+- Updated dependencies [604caff]
+  - @fragno-dev/core@0.0.3
+
+## 0.0.2
+
+### Patch Changes
+
+- Updated dependencies [2052919]
+  - @fragno-dev/core@0.0.2

package/dist/fragno-node.d.ts

@@ -0,0 +1,45 @@
+import { RequestListener } from "node:http";
+
+//#region fragno-node.d.ts
+
+/**
+ * Creates a handler that can be used with `node:http` to serve backend requests based on a Fragno
+ * fragment (library).
+ *
+ * @example
+ * import { createServer } from "node:http";
+ * import { toNodeHandler } from "@fragno-dev/node";
+ * import { createExampleFragment } from "@fragno-dev/example-fragment";
+ *
+ * const fragment = createExampleFragment();
+ *
+ * const server = createServer(toNodeHandler(fragment.handler));
+ * server.listen(8080);
+ *
+ * @example
+ * import { createServer } from "node:http";
+ * import { toNodeHandler } from "@fragno-dev/node";
+ * import { createExampleFragment } from "@fragno-dev/example-fragment";
+ *
+ * const fragment = createExampleFragment();
+ *
+ * const server = createServer((req, res) => {
+ *   if (req.url?.startsWith(fragment.mountRoute)) {
+ *     const handler = toNodeHandler(fragment.handler);
+ *     return handler(req, res);
+ *   }
+ *   // ... Your route handling
+ * });
+ * @example
+ * import express from "express";
+ * import { toNodeHandler } from "@fragno-dev/node";
+ *
+ * const app = express();
+ * app.all("/api/my-library/{*any}", toNodeHandler(fragment.handler));
+ *
+ * app.listen(8080);
+ */
+declare function toNodeHandler(handler: (req: Request) => Promise<Response>): RequestListener;
+//#endregion
+export { toNodeHandler };
+//# sourceMappingURL=fragno-node.d.ts.map

package/dist/fragno-node.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fragno-node.d.ts","names":[],"sources":["../fragno-node.ts"],"sourcesContent":[],"mappings":";;;;;;AAwCA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAAgB,aAAA,gBAA6B,YAAY,QAAQ,YAAY"}

package/dist/fragno-node.js

@@ -0,0 +1,47 @@
+import { createRequestListener } from "@remix-run/node-fetch-server";
+
+//#region fragno-node.ts
+/**
+* Creates a handler that can be used with `node:http` to serve backend requests based on a Fragno
+* fragment (library).
+*
+* @example
+* import { createServer } from "node:http";
+* import { toNodeHandler } from "@fragno-dev/node";
+* import { createExampleFragment } from "@fragno-dev/example-fragment";
+*
+* const fragment = createExampleFragment();
+*
+* const server = createServer(toNodeHandler(fragment.handler));
+* server.listen(8080);
+*
+* @example
+* import { createServer } from "node:http";
+* import { toNodeHandler } from "@fragno-dev/node";
+* import { createExampleFragment } from "@fragno-dev/example-fragment";
+*
+* const fragment = createExampleFragment();
+*
+* const server = createServer((req, res) => {
+*   if (req.url?.startsWith(fragment.mountRoute)) {
+*     const handler = toNodeHandler(fragment.handler);
+*     return handler(req, res);
+*   }
+*   // ... Your route handling
+* });
+* @example
+* import express from "express";
+* import { toNodeHandler } from "@fragno-dev/node";
+*
+* const app = express();
+* app.all("/api/my-library/{*any}", toNodeHandler(fragment.handler));
+*
+* app.listen(8080);
+*/
+function toNodeHandler(handler) {
+	return createRequestListener(handler);
+}
+
+//#endregion
+export { toNodeHandler };
+//# sourceMappingURL=fragno-node.js.map

package/dist/fragno-node.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"fragno-node.js","names":[],"sources":["../fragno-node.ts"],"sourcesContent":["import type { RequestListener } from \"node:http\";\nimport { createRequestListener } from \"@remix-run/node-fetch-server\";\n\n/**\n * Creates a handler that can be used with `node:http` to serve backend requests based on a Fragno\n * fragment (library).\n *\n * @example\n * import { createServer } from \"node:http\";\n * import { toNodeHandler } from \"@fragno-dev/node\";\n * import { createExampleFragment } from \"@fragno-dev/example-fragment\";\n *\n * const fragment = createExampleFragment();\n *\n * const server = createServer(toNodeHandler(fragment.handler));\n * server.listen(8080);\n *\n * @example\n * import { createServer } from \"node:http\";\n * import { toNodeHandler } from \"@fragno-dev/node\";\n * import { createExampleFragment } from \"@fragno-dev/example-fragment\";\n *\n * const fragment = createExampleFragment();\n *\n * const server = createServer((req, res) => {\n *   if (req.url?.startsWith(fragment.mountRoute)) {\n *     const handler = toNodeHandler(fragment.handler);\n *     return handler(req, res);\n *   }\n *   // ... Your route handling\n * });\n * @example\n * import express from \"express\";\n * import { toNodeHandler } from \"@fragno-dev/node\";\n *\n * const app = express();\n * app.all(\"/api/my-library/{*any}\", toNodeHandler(fragment.handler));\n *\n * app.listen(8080);\n */\nexport function toNodeHandler(handler: (req: Request) => Promise<Response>): RequestListener {\n  return createRequestListener(handler);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAwCA,SAAgB,cAAc,SAA+D;AAC3F,QAAO,sBAAsB,QAAQ"}

package/fragno-node-express.test.ts

@@ -0,0 +1,77 @@
+import express, { type Application } from "express";
+import { test, expect, describe, beforeAll, afterAll } from "vitest";
+import { z } from "zod";
+import {
+  defineFragment,
+  defineRoute,
+  createFragment,
+  type FragnoInstantiatedFragment,
+  type FragnoPublicClientConfig,
+} from "@fragno-dev/core";
+import { toNodeHandler } from "./fragno-node";
+
+describe("Fragno Express integration", () => {
+  const testFragmentDefinition = defineFragment("test-fragment");
+
+  const usersRoute = defineRoute({
+    method: "GET",
+    path: "/users",
+    outputSchema: z.array(z.object({ id: z.number(), name: z.string() })),
+    handler: async (_ctx, { json }) => json([{ id: 1, name: "John" }]),
+  });
+
+  const clientConfig: FragnoPublicClientConfig = {
+    baseUrl: "http://localhost",
+  };
+  let testFragment: FragnoInstantiatedFragment<[typeof usersRoute]>;
+  let app: Application;
+  let server: ReturnType<typeof app.listen>;
+  let port: number;
+
+  function createExpressServerForTest() {
+    testFragment = createFragment(testFragmentDefinition, {}, [usersRoute], clientConfig);
+    app = express();
+
+    app.all("/api/test-fragment/{*any}", toNodeHandler(testFragment.handler));
+
+    // Add JSON body parsing middleware
+    app.use(express.json());
+    app.get("/some-other-route", (_req, res) => {
+      res.writeHead(200, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ message: "Hello world" }));
+    });
+
+    server = app.listen(0);
+
+    const address = server.address();
+    if (!address || typeof address === "string") {
+      throw new Error("Address invalid");
+    }
+
+    port = address.port;
+    clientConfig.baseUrl = `http://localhost:${port}`;
+  }
+
+  beforeAll(() => {
+    createExpressServerForTest();
+  });
+
+  afterAll(() => {
+    server.close();
+  });
+
+  test("should fetch data from the GET /users route", async () => {
+    const response = await fetch(`${clientConfig.baseUrl}${testFragment.mountRoute}/users`);
+
+    expect(response.ok).toBe(true);
+
+    const data = await response.json();
+    expect(data).toEqual([{ id: 1, name: "John" }]);
+  });
+
+  test("should fall back to normal express routes for non-lib routes", async () => {
+    const response = await fetch(`${clientConfig.baseUrl}/some-other-route`);
+    const data = await response.json();
+    expect(data).toEqual({ message: "Hello world" });
+  });
+});

package/fragno-node-http.test.ts

@@ -0,0 +1,81 @@
+import { createServer, type RequestListener, type Server } from "node:http";
+import { test, expect, describe } from "vitest";
+import { z } from "zod";
+import {
+  defineFragment,
+  defineRoute,
+  createFragment,
+  type FragnoInstantiatedFragment,
+  type FragnoPublicClientConfig,
+} from "@fragno-dev/core";
+import { toNodeHandler } from "./fragno-node";
+
+describe("Fragno Node.js integration", () => {
+  const testFragmentDefinition = defineFragment("test-fragment");
+
+  const usersRoute = defineRoute({
+    method: "GET",
+    path: "/users",
+    outputSchema: z.array(z.object({ id: z.number(), name: z.string() })),
+    handler: async (_ctx, { json }) => json([{ id: 1, name: "John" }]),
+  });
+
+  const clientConfig: FragnoPublicClientConfig = {
+    baseUrl: "http://localhost",
+  };
+  let testFragment: FragnoInstantiatedFragment<[typeof usersRoute]>;
+  let server: Server;
+  let port: number;
+
+  function createServerForTest(
+    listenerFactory: (fragment: FragnoInstantiatedFragment<[typeof usersRoute]>) => RequestListener,
+  ) {
+    testFragment = createFragment(testFragmentDefinition, {}, [usersRoute], clientConfig);
+    server = createServer(listenerFactory(testFragment));
+    server.listen(0);
+
+    const address = server.address();
+    if (!address || typeof address === "string") {
+      throw new Error("Address invalid");
+    }
+
+    port = address.port;
+    clientConfig.baseUrl = `http://localhost:${port}`;
+
+    return {
+      close: () => server.close(),
+    };
+  }
+
+  test("should fetch data from the GET /users route", async () => {
+    const { close } = createServerForTest((fragment) => toNodeHandler(fragment.handler));
+
+    const response = await fetch(`${clientConfig.baseUrl}${testFragment.mountRoute}/users`);
+
+    expect(response.ok).toBe(true);
+
+    const data = await response.json();
+    expect(data).toEqual([{ id: 1, name: "John" }]);
+
+    close();
+  });
+
+  test("should fall back to normal server for non-lib routes", async () => {
+    const { close } = createServerForTest((fragment) => (req, res) => {
+      if (req.url?.startsWith(fragment.mountRoute)) {
+        const handler = toNodeHandler(fragment.handler);
+        return handler(req, res);
+      } else {
+        res.writeHead(200, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ message: "It's working." }));
+      }
+    });
+
+    const response = await fetch(`${clientConfig.baseUrl}/`);
+    expect(response.ok).toBe(true);
+    const data = await response.json();
+    expect(data).toEqual({ message: "It's working." });
+
+    close();
+  });
+});

package/fragno-node.ts

@@ -0,0 +1,43 @@
+import type { RequestListener } from "node:http";
+import { createRequestListener } from "@remix-run/node-fetch-server";
+
+/**
+ * Creates a handler that can be used with `node:http` to serve backend requests based on a Fragno
+ * fragment (library).
+ *
+ * @example
+ * import { createServer } from "node:http";
+ * import { toNodeHandler } from "@fragno-dev/node";
+ * import { createExampleFragment } from "@fragno-dev/example-fragment";
+ *
+ * const fragment = createExampleFragment();
+ *
+ * const server = createServer(toNodeHandler(fragment.handler));
+ * server.listen(8080);
+ *
+ * @example
+ * import { createServer } from "node:http";
+ * import { toNodeHandler } from "@fragno-dev/node";
+ * import { createExampleFragment } from "@fragno-dev/example-fragment";
+ *
+ * const fragment = createExampleFragment();
+ *
+ * const server = createServer((req, res) => {
+ *   if (req.url?.startsWith(fragment.mountRoute)) {
+ *     const handler = toNodeHandler(fragment.handler);
+ *     return handler(req, res);
+ *   }
+ *   // ... Your route handling
+ * });
+ * @example
+ * import express from "express";
+ * import { toNodeHandler } from "@fragno-dev/node";
+ *
+ * const app = express();
+ * app.all("/api/my-library/{*any}", toNodeHandler(fragment.handler));
+ *
+ * app.listen(8080);
+ */
+export function toNodeHandler(handler: (req: Request) => Promise<Response>): RequestListener {
+  return createRequestListener(handler);
+}

package/node-stream.test.ts

@@ -0,0 +1,94 @@
+import express, { type Application } from "express";
+import { test, expect, describe, beforeAll, afterAll, assert } from "vitest";
+import { z } from "zod";
+import {
+  defineFragment,
+  defineRoute,
+  createFragment,
+  type FragnoInstantiatedFragment,
+  type FragnoPublicClientConfig,
+} from "@fragno-dev/core";
+import { toNodeHandler } from "./fragno-node";
+
+describe("Node.js Streaming", () => {
+  const testFragmentDefinition = defineFragment("test-fragment");
+
+  const streamRoute = defineRoute({
+    method: "GET",
+    path: "/stream",
+    outputSchema: z.array(z.object({ message: z.string() })),
+    handler: async (_ctx, { jsonStream }) => {
+      return jsonStream(async (stream) => {
+        await stream.write({ message: "Hello, " });
+        await stream.sleep(1);
+        await stream.write({ message: "World!" });
+      });
+    },
+  });
+
+  const clientConfig: FragnoPublicClientConfig = {
+    baseUrl: "http://localhost",
+  };
+  let testFragment: FragnoInstantiatedFragment<[typeof streamRoute]>;
+  let app: Application;
+  let server: ReturnType<typeof app.listen>;
+  let port: number;
+
+  function createExpressServerForTest() {
+    testFragment = createFragment(testFragmentDefinition, {}, [streamRoute], clientConfig);
+    app = express();
+
+    app.all("/api/test-fragment/{*any}", toNodeHandler(testFragment.handler));
+
+    // Add JSON body parsing middleware
+    app.use(express.json());
+    app.get("/some-other-route", (_req, res) => {
+      res.writeHead(200, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ message: "Hello world" }));
+    });
+
+    server = app.listen(0);
+
+    const address = server.address();
+    if (!address || typeof address === "string") {
+      throw new Error("Address invalid");
+    }
+
+    port = address.port;
+    clientConfig.baseUrl = `http://localhost:${port}`;
+  }
+
+  beforeAll(() => {
+    createExpressServerForTest();
+  });
+
+  afterAll(() => {
+    server.close();
+  });
+
+  test("should fetch data from the GET /stream route", async () => {
+    const response = await fetch(`${clientConfig.baseUrl}${testFragment.mountRoute}/stream`);
+
+    assert(response.body, "Response body is missing");
+
+    expect(response.headers.get("content-type")).toBe("application/x-ndjson; charset=utf-8");
+    expect(response.headers.get("cache-control")).toBe("no-cache");
+    expect(response.headers.get("transfer-encoding")).toBe("chunked");
+
+    const decoder = new TextDecoder();
+    let result = "";
+    for await (const chunk of response.body) {
+      const string = decoder.decode(chunk, { stream: true });
+      const lines = string.split("\n");
+      for (const line of lines) {
+        if (!line) {
+          continue;
+        }
+
+        const jsonObject = JSON.parse(line);
+        result += jsonObject.message;
+      }
+    }
+    expect(result).toBe("Hello, World!");
+  });
+});

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "@fragno-dev/node",
+  "version": "0.0.5",
+  "exports": {
+    ".": {
+      "bun": "./fragno-node.ts",
+      "development": "./fragno-node.ts",
+      "types": "./dist/fragno-node.d.ts",
+      "default": "./dist/fragno-node.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "type": "module",
+  "scripts": {
+    "build": "tsdown",
+    "build:watch": "tsdown --watch",
+    "types:check": "tsc --noEmit"
+  },
+  "peerDependencies": {
+    "@fragno-dev/core": "0.0.5"
+  },
+  "engines": {
+    "node": "^20.0.0 || >=22.0.0"
+  },
+  "devDependencies": {
+    "@fragno-dev/core": "0.0.5",
+    "@fragno-private/typescript-config": "0.0.1",
+    "@types/node": "^22",
+    "@types/express": "^5.0.3",
+    "express": "^5.1.0",
+    "zod": "^4.0.5"
+  },
+  "dependencies": {
+    "@remix-run/node-fetch-server": "^0.8.0"
+  },
+  "main": "./dist/fragno-node.js",
+  "module": "./dist/fragno-node.js",
+  "types": "./dist/fragno-node.d.ts"
+}

package/tsconfig.json

@@ -0,0 +1,10 @@
+{
+  "extends": "@fragno-private/typescript-config/tsconfig.base.json",
+  "compilerOptions": {
+    "outDir": "./dist",
+    "rootDir": ".",
+    "composite": true
+  },
+  "include": ["*.ts"],
+  "exclude": ["node_modules", "dist"]
+}

package/tsdown.config.ts

@@ -0,0 +1,6 @@
+import { defineConfig } from "tsdown";
+
+export default defineConfig({
+  entry: "./fragno-node.ts",
+  dts: true,
+});

package/vitest.config.ts

@@ -0,0 +1,3 @@
+import { defineConfig } from "vitest/config";
+
+export default defineConfig({});