@tanstack/start-static-server-functions 1.121.0-alpha.28

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021-present Tanner Linsley
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/esm/index.d.ts

@@ -0,0 +1 @@
+export { staticFunctionMiddleware } from './staticFunctionMiddleware.js';

package/dist/esm/index.js

@@ -0,0 +1,5 @@
+import { staticFunctionMiddleware } from "./staticFunctionMiddleware.js";
+export {
+  staticFunctionMiddleware
+};
+//# sourceMappingURL=index.js.map

package/dist/esm/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";"}

package/dist/esm/staticFunctionMiddleware.d.ts

@@ -0,0 +1 @@
+export declare const staticFunctionMiddleware: import('@tanstack/start-client-core').FunctionMiddlewareAfterServer<unknown, undefined, undefined, undefined, undefined, undefined, import('@tanstack/start-client-core').ServerFnResponseType>;

package/dist/esm/staticFunctionMiddleware.js

@@ -0,0 +1,98 @@
+import { createMiddleware, startSerializer } from "@tanstack/start-client-core";
+async function sha1Hash(message) {
+  const msgBuffer = new TextEncoder().encode(message);
+  const hashBuffer = await crypto.subtle.digest("SHA-1", msgBuffer);
+  const hashArray = Array.from(new Uint8Array(hashBuffer));
+  const hashHex = hashArray.map((b) => b.toString(16).padStart(2, "0")).join("");
+  return hashHex;
+}
+const getStaticCacheUrl = async (opts) => {
+  const filename = await sha1Hash(`${opts.functionId}__${opts.hash}`);
+  return `/__tsr/staticServerFnCache/${filename}.json`;
+};
+const jsonToFilenameSafeString = (json) => {
+  const sortedKeysReplacer = (key, value) => value && typeof value === "object" && !Array.isArray(value) ? Object.keys(value).sort().reduce((acc, curr) => {
+    acc[curr] = value[curr];
+    return acc;
+  }, {}) : value;
+  const jsonString = JSON.stringify(json ?? "", sortedKeysReplacer);
+  return jsonString.replace(/[/\\?%*:|"<>]/g, "-").replace(/\s+/g, "_");
+};
+const staticClientCache = typeof document !== "undefined" ? /* @__PURE__ */ new Map() : null;
+const serverFnStaticCache = {
+  getItem: async (ctx) => {
+    if (typeof document === "undefined") {
+      const hash = jsonToFilenameSafeString(ctx.data);
+      const url = await getStaticCacheUrl({ functionId: ctx.functionId, hash });
+      const publicUrl = process.env.TSS_OUTPUT_PUBLIC_DIR;
+      const { promises: fs } = await import("node:fs");
+      const path = await import("node:path");
+      const filePath = path.join(publicUrl, url);
+      const [cachedResult, readError] = await fs.readFile(filePath, "utf-8").then((c) => [startSerializer.parse(c), null]).catch((e) => [null, e]);
+      if (readError && readError.code !== "ENOENT") {
+        throw readError;
+      }
+      return cachedResult;
+    }
+    return void 0;
+  },
+  setItem: async ({ data, functionId, response }) => {
+    const { promises: fs } = await import("node:fs");
+    const path = await import("node:path");
+    const hash = jsonToFilenameSafeString(data);
+    const url = await getStaticCacheUrl({ functionId, hash });
+    const publicUrl = process.env.TSS_OUTPUT_PUBLIC_DIR;
+    const filePath = path.join(publicUrl, url);
+    await fs.mkdir(path.dirname(filePath), { recursive: true });
+    await fs.writeFile(
+      filePath,
+      startSerializer.stringify({
+        result: response.result,
+        context: response.context.sendContext
+      }),
+      "utf-8"
+    );
+  }
+};
+const fetchItem = async ({
+  data,
+  functionId
+}) => {
+  const hash = jsonToFilenameSafeString(data);
+  const url = await getStaticCacheUrl({ functionId, hash });
+  let result = staticClientCache?.get(url);
+  result = await fetch(url, {
+    method: "GET"
+  }).then((r) => r.text()).then((d) => startSerializer.parse(d));
+  return result;
+};
+const staticFunctionMiddleware = createMiddleware({ type: "function" }).client(async (ctx) => {
+  if (process.env.NODE_ENV === "production" && // do not run this during SSR on the server
+  typeof document !== "undefined") {
+    const response = await fetchItem({
+      functionId: ctx.functionId,
+      data: ctx.data
+    });
+    if (response) {
+      return {
+        result: response.result,
+        context: { ...ctx.context, ...response.context }
+      };
+    }
+  }
+  return ctx.next();
+}).server(async (ctx) => {
+  const response = await ctx.next();
+  if (process.env.NODE_ENV === "production") {
+    await serverFnStaticCache.setItem({
+      functionId: ctx.functionId,
+      response: { result: response.result, context: ctx },
+      data: ctx.data
+    });
+  }
+  return response;
+});
+export {
+  staticFunctionMiddleware
+};
+//# sourceMappingURL=staticFunctionMiddleware.js.map

package/dist/esm/staticFunctionMiddleware.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"staticFunctionMiddleware.js","sources":["../../src/staticFunctionMiddleware.ts"],"sourcesContent":["import { createMiddleware, startSerializer } from '@tanstack/start-client-core'\n\ntype StaticCachedResult = {\n  result: any\n  context: any\n}\n\ntype ServerFnStaticCache = {\n  getItem: (opts: {\n    functionId: string\n    data: any\n  }) => StaticCachedResult | Promise<StaticCachedResult | undefined>\n  setItem: (opts: {\n    functionId: string\n    data: any\n    response: StaticCachedResult\n  }) => Promise<void>\n}\n\n/**\n * This is a simple hash function for generating a hash from a string to make the filenames shorter.\n *\n * It is not cryptographically secure (as its using SHA-1) and should not be used for any security purposes.\n *\n * It is only used to generate a hash for the static cache filenames.\n *\n * @param message - The input string to hash.\n * @returns A promise that resolves to the SHA-1 hash of the input string in hexadecimal format.\n *\n * @example\n * ```typescript\n * const hash = await sha1Hash(\"hello\");\n * console.log(hash); // Outputs the SHA-1 hash of \"hello\" -> \"aaf4c61ddcc5e8a2dabede0f3b482cd9aea9434d\"\n * ```\n */\nasync function sha1Hash(message: string): Promise<string> {\n  // Encode the string as UTF-8\n  const msgBuffer = new TextEncoder().encode(message)\n\n  // Hash the message\n  const hashBuffer = await crypto.subtle.digest('SHA-1', msgBuffer)\n\n  // Convert the ArrayBuffer to a string\n  const hashArray = Array.from(new Uint8Array(hashBuffer))\n  const hashHex = hashArray.map((b) => b.toString(16).padStart(2, '0')).join('')\n  return hashHex\n}\n\nconst getStaticCacheUrl = async (opts: {\n  functionId: string\n  hash: string\n}) => {\n  const filename = await sha1Hash(`${opts.functionId}__${opts.hash}`)\n  return `/__tsr/staticServerFnCache/${filename}.json`\n}\n\nconst jsonToFilenameSafeString = (json: any) => {\n  // Custom replacer to sort keys\n  const sortedKeysReplacer = (key: string, value: any) =>\n    value && typeof value === 'object' && !Array.isArray(value)\n      ? Object.keys(value)\n          .sort()\n          .reduce((acc: any, curr: string) => {\n            acc[curr] = value[curr]\n            return acc\n          }, {})\n      : value\n\n  // Convert JSON to string with sorted keys\n  const jsonString = JSON.stringify(json ?? '', sortedKeysReplacer)\n\n  // Replace characters invalid in filenames\n  return jsonString\n    .replace(/[/\\\\?%*:|\"<>]/g, '-') // Replace invalid characters with a dash\n    .replace(/\\s+/g, '_') // Optionally replace whitespace with underscores\n}\n\nconst staticClientCache =\n  typeof document !== 'undefined' ? new Map<string, any>() : null\n\nconst serverFnStaticCache: ServerFnStaticCache = {\n  getItem: async (ctx) => {\n    if (typeof document === 'undefined') {\n      const hash = jsonToFilenameSafeString(ctx.data)\n      const url = await getStaticCacheUrl({ functionId: ctx.functionId, hash })\n      const publicUrl = process.env.TSS_OUTPUT_PUBLIC_DIR!\n\n      // Use fs instead of fetch to read from filesystem\n      const { promises: fs } = await import('node:fs')\n      const path = await import('node:path')\n      const filePath = path.join(publicUrl, url)\n\n      const [cachedResult, readError] = await fs\n        .readFile(filePath, 'utf-8')\n        .then((c) => [startSerializer.parse(c), null])\n        .catch((e) => [null, e])\n\n      if (readError && readError.code !== 'ENOENT') {\n        throw readError\n      }\n\n      return cachedResult as StaticCachedResult\n    }\n\n    return undefined\n  },\n  setItem: async ({ data, functionId, response }) => {\n    const { promises: fs } = await import('node:fs')\n    const path = await import('node:path')\n\n    const hash = jsonToFilenameSafeString(data)\n    const url = await getStaticCacheUrl({ functionId, hash })\n    const publicUrl = process.env.TSS_OUTPUT_PUBLIC_DIR!\n    const filePath = path.join(publicUrl, url)\n\n    // Ensure the directory exists\n    await fs.mkdir(path.dirname(filePath), { recursive: true })\n\n    // Store the result with fs\n    await fs.writeFile(\n      filePath,\n      startSerializer.stringify({\n        result: response.result,\n        context: response.context.sendContext,\n      }),\n      'utf-8',\n    )\n  },\n}\n\nconst fetchItem = async ({\n  data,\n  functionId,\n}: {\n  data: any\n  functionId: string\n}) => {\n  const hash = jsonToFilenameSafeString(data)\n  const url = await getStaticCacheUrl({ functionId, hash })\n\n  let result: any = staticClientCache?.get(url)\n\n  result = await fetch(url, {\n    method: 'GET',\n  })\n    .then((r) => r.text())\n    .then((d) => startSerializer.parse(d))\n\n  return result\n}\n\nexport const staticFunctionMiddleware = createMiddleware({ type: 'function' })\n  .client(async (ctx) => {\n    if (\n      process.env.NODE_ENV === 'production' &&\n      // do not run this during SSR on the server\n      typeof document !== 'undefined'\n    ) {\n      const response = await fetchItem({\n        functionId: ctx.functionId,\n        data: ctx.data,\n      })\n\n      if (response) {\n        return {\n          result: response.result,\n          context: { ...(ctx as any).context, ...response.context },\n        } as any\n      }\n    }\n    return ctx.next()\n  })\n  .server(async (ctx) => {\n    const response = await ctx.next()\n\n    if (process.env.NODE_ENV === 'production') {\n      await serverFnStaticCache.setItem({\n        functionId: ctx.functionId,\n        response: { result: (response as any).result, context: ctx },\n        data: ctx.data,\n      })\n    }\n\n    return response\n  })\n"],"names":[],"mappings":"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"}

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "@tanstack/start-static-server-functions",
+  "version": "1.121.0-alpha.28",
+  "description": "Modern and scalable routing for React applications",
+  "author": "Tanner Linsley",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/TanStack/router.git",
+    "directory": "packages/start-static-server-functions"
+  },
+  "homepage": "https://tanstack.com/start",
+  "funding": {
+    "type": "github",
+    "url": "https://github.com/sponsors/tannerlinsley"
+  },
+  "keywords": [
+    "react",
+    "location",
+    "router",
+    "routing",
+    "async",
+    "async router",
+    "typescript"
+  ],
+  "type": "module",
+  "types": "dist/esm/index.d.ts",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/esm/index.d.ts",
+        "default": "./dist/esm/index.js"
+      }
+    },
+    "./package.json": "./package.json"
+  },
+  "sideEffects": false,
+  "files": [
+    "dist",
+    "src"
+  ],
+  "engines": {
+    "node": ">=12"
+  },
+  "dependencies": {
+    "@tanstack/start-client-core": "1.121.0-alpha.28"
+  },
+  "scripts": {}
+}

package/src/index.ts

@@ -0,0 +1 @@
+export { staticFunctionMiddleware } from './staticFunctionMiddleware'

package/src/staticFunctionMiddleware.ts

@@ -0,0 +1,185 @@
+import { createMiddleware, startSerializer } from '@tanstack/start-client-core'
+
+type StaticCachedResult = {
+  result: any
+  context: any
+}
+
+type ServerFnStaticCache = {
+  getItem: (opts: {
+    functionId: string
+    data: any
+  }) => StaticCachedResult | Promise<StaticCachedResult | undefined>
+  setItem: (opts: {
+    functionId: string
+    data: any
+    response: StaticCachedResult
+  }) => Promise<void>
+}
+
+/**
+ * This is a simple hash function for generating a hash from a string to make the filenames shorter.
+ *
+ * It is not cryptographically secure (as its using SHA-1) and should not be used for any security purposes.
+ *
+ * It is only used to generate a hash for the static cache filenames.
+ *
+ * @param message - The input string to hash.
+ * @returns A promise that resolves to the SHA-1 hash of the input string in hexadecimal format.
+ *
+ * @example
+ * ```typescript
+ * const hash = await sha1Hash("hello");
+ * console.log(hash); // Outputs the SHA-1 hash of "hello" -> "aaf4c61ddcc5e8a2dabede0f3b482cd9aea9434d"
+ * ```
+ */
+async function sha1Hash(message: string): Promise<string> {
+  // Encode the string as UTF-8
+  const msgBuffer = new TextEncoder().encode(message)
+
+  // Hash the message
+  const hashBuffer = await crypto.subtle.digest('SHA-1', msgBuffer)
+
+  // Convert the ArrayBuffer to a string
+  const hashArray = Array.from(new Uint8Array(hashBuffer))
+  const hashHex = hashArray.map((b) => b.toString(16).padStart(2, '0')).join('')
+  return hashHex
+}
+
+const getStaticCacheUrl = async (opts: {
+  functionId: string
+  hash: string
+}) => {
+  const filename = await sha1Hash(`${opts.functionId}__${opts.hash}`)
+  return `/__tsr/staticServerFnCache/${filename}.json`
+}
+
+const jsonToFilenameSafeString = (json: any) => {
+  // Custom replacer to sort keys
+  const sortedKeysReplacer = (key: string, value: any) =>
+    value && typeof value === 'object' && !Array.isArray(value)
+      ? Object.keys(value)
+          .sort()
+          .reduce((acc: any, curr: string) => {
+            acc[curr] = value[curr]
+            return acc
+          }, {})
+      : value
+
+  // Convert JSON to string with sorted keys
+  const jsonString = JSON.stringify(json ?? '', sortedKeysReplacer)
+
+  // Replace characters invalid in filenames
+  return jsonString
+    .replace(/[/\\?%*:|"<>]/g, '-') // Replace invalid characters with a dash
+    .replace(/\s+/g, '_') // Optionally replace whitespace with underscores
+}
+
+const staticClientCache =
+  typeof document !== 'undefined' ? new Map<string, any>() : null
+
+const serverFnStaticCache: ServerFnStaticCache = {
+  getItem: async (ctx) => {
+    if (typeof document === 'undefined') {
+      const hash = jsonToFilenameSafeString(ctx.data)
+      const url = await getStaticCacheUrl({ functionId: ctx.functionId, hash })
+      const publicUrl = process.env.TSS_OUTPUT_PUBLIC_DIR!
+
+      // Use fs instead of fetch to read from filesystem
+      const { promises: fs } = await import('node:fs')
+      const path = await import('node:path')
+      const filePath = path.join(publicUrl, url)
+
+      const [cachedResult, readError] = await fs
+        .readFile(filePath, 'utf-8')
+        .then((c) => [startSerializer.parse(c), null])
+        .catch((e) => [null, e])
+
+      if (readError && readError.code !== 'ENOENT') {
+        throw readError
+      }
+
+      return cachedResult as StaticCachedResult
+    }
+
+    return undefined
+  },
+  setItem: async ({ data, functionId, response }) => {
+    const { promises: fs } = await import('node:fs')
+    const path = await import('node:path')
+
+    const hash = jsonToFilenameSafeString(data)
+    const url = await getStaticCacheUrl({ functionId, hash })
+    const publicUrl = process.env.TSS_OUTPUT_PUBLIC_DIR!
+    const filePath = path.join(publicUrl, url)
+
+    // Ensure the directory exists
+    await fs.mkdir(path.dirname(filePath), { recursive: true })
+
+    // Store the result with fs
+    await fs.writeFile(
+      filePath,
+      startSerializer.stringify({
+        result: response.result,
+        context: response.context.sendContext,
+      }),
+      'utf-8',
+    )
+  },
+}
+
+const fetchItem = async ({
+  data,
+  functionId,
+}: {
+  data: any
+  functionId: string
+}) => {
+  const hash = jsonToFilenameSafeString(data)
+  const url = await getStaticCacheUrl({ functionId, hash })
+
+  let result: any = staticClientCache?.get(url)
+
+  result = await fetch(url, {
+    method: 'GET',
+  })
+    .then((r) => r.text())
+    .then((d) => startSerializer.parse(d))
+
+  return result
+}
+
+export const staticFunctionMiddleware = createMiddleware({ type: 'function' })
+  .client(async (ctx) => {
+    if (
+      process.env.NODE_ENV === 'production' &&
+      // do not run this during SSR on the server
+      typeof document !== 'undefined'
+    ) {
+      const response = await fetchItem({
+        functionId: ctx.functionId,
+        data: ctx.data,
+      })
+
+      if (response) {
+        return {
+          result: response.result,
+          context: { ...(ctx as any).context, ...response.context },
+        } as any
+      }
+    }
+    return ctx.next()
+  })
+  .server(async (ctx) => {
+    const response = await ctx.next()
+
+    if (process.env.NODE_ENV === 'production') {
+      await serverFnStaticCache.setItem({
+        functionId: ctx.functionId,
+        response: { result: (response as any).result, context: ctx },
+        data: ctx.data,
+      })
+    }
+
+    return response
+  })