@rebasepro/server 0.12.0 → 0.12.1-canary.gdfba2a1

package/dist/function-loader-B_1fYfUY.js

@@ -0,0 +1,86 @@
+import { createRequire as __createRequire } from "module";
+import "process";
+__createRequire(import.meta.url);
+import { n as __exportAll } from "./rolldown-runtime-DSJWtz9O.js";
+import { t as logger } from "./logger-BYU66ENZ.js";
+import { t as nativeDynamicImport } from "./dynamic-import-Dvh-K5fl.js";
+import * as fs$1 from "fs";
+import * as path$1 from "path";
+import { pathToFileURL } from "url";
+//#region src/functions/function-loader.ts
+var function_loader_exports = /* @__PURE__ */ __exportAll({ loadFunctionsFromDirectory: () => loadFunctionsFromDirectory });
+/**
+* Auto-discover Hono route files from a directory.
+*
+* Each file should default-export a Hono app (or router).
+* The filename (without extension) becomes the mount path:
+*   `functions/send-invoice.ts` → mounted at `/send-invoice`
+*
+* This mirrors how `loadCollectionsFromDirectory` works for collections.
+*/
+async function loadFunctionsFromDirectory(directory, importModule = nativeDynamicImport) {
+	const functions = [];
+	const problems = [];
+	if (!fs$1.existsSync(directory)) return functions;
+	const files = fs$1.readdirSync(directory);
+	for (const file of files) if ((file.endsWith(".ts") || file.endsWith(".js")) && !file.startsWith(".") && !file.includes(".test.") && !file.endsWith(".d.ts") && file !== "index.ts" && file !== "index.js") {
+		const filePath = path$1.join(directory, file);
+		try {
+			const fileUrl = pathToFileURL(filePath).href;
+			const exported = (await importModule(fileUrl)).default;
+			if (!exported) {
+				logger.warn(`[functions] ${file}: no default export. Skipping.`);
+				problems.push(`${file} (no default export)`);
+				continue;
+			}
+			if (isHonoLike(exported)) {
+				const name = path$1.basename(file, path$1.extname(file));
+				functions.push({
+					name,
+					app: exported
+				});
+				logger.info(`⚡ Loaded function route: ${name}`);
+				continue;
+			}
+			if (typeof exported === "function") {
+				const result = exported();
+				if (isHonoLike(result)) {
+					const name = path$1.basename(file, path$1.extname(file));
+					functions.push({
+						name,
+						app: result
+					});
+					logger.info(`⚡ Loaded function route: ${name}`);
+					continue;
+				}
+			}
+			const exportType = typeof exported;
+			const keys = exported && typeof exported === "object" ? Object.getOwnPropertyNames(Object.getPrototypeOf(exported)).slice(0, 10).join(", ") : "N/A";
+			logger.warn(`[functions] ${file}: default export is not a Hono app or factory. Skipping.\n  export type: ${exportType}${exported?.constructor?.name ? ` (${exported.constructor.name})` : ""}\n  prototype methods: ${keys}\n  Hint: ensure the function exports a Hono app created with the same hono version as the server.
+  Author with \`defineFunction(...)\` from @rebasepro/server for a typed, checked contract.
+  The loader checks for .fetch() and .routes — any Hono-compatible app will work.`);
+			problems.push(`${file} (not a Hono app or factory)`);
+		} catch (err) {
+			const message = err instanceof Error ? err.message : String(err);
+			logger.error(`[functions] Failed to load ${file}: ${message}`);
+			problems.push(`${file} (threw: ${message})`);
+		}
+	}
+	if (problems.length > 0) logger.warn(`[functions] ${problems.length} function file(s) were skipped and will NOT be served:\n` + problems.map((p) => `  - ${p}`).join("\n") + "\n  Fix these or author them with `defineFunction(...)` for a typed, compile-checked contract.");
+	return functions;
+}
+/**
+* Duck-type check for Hono apps.
+* We avoid `instanceof Hono` because different Hono versions
+* installed in the user's project vs. our dependencies will
+* not share the same prototype, causing false negatives.
+*/
+function isHonoLike(obj) {
+	if (!obj || typeof obj !== "object") return false;
+	const record = obj;
+	return typeof record.fetch === "function" && Array.isArray(record.routes);
+}
+//#endregion
+export { loadFunctionsFromDirectory as n, function_loader_exports as t };
+
+//# sourceMappingURL=function-loader-B_1fYfUY.js.map

package/dist/function-loader-B_1fYfUY.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"function-loader-B_1fYfUY.js","names":[],"sources":["../src/functions/function-loader.ts"],"sourcesContent":["import * as fs from \"fs\";\nimport * as path from \"path\";\nimport { pathToFileURL } from \"url\";\nimport { Hono } from \"hono\";\nimport { logger } from \"../utils/logger.js\";\nimport { nativeDynamicImport, type ModuleImporter } from \"../utils/dynamic-import.js\";\n\nexport interface LoadedFunction {\n    /** Endpoint name derived from filename (e.g., \"send-invoice\") */\n    name: string;\n    /** The Hono sub-app to mount */\n    app: Hono<import(\"hono\").Env>;\n}\n\n/**\n * Auto-discover Hono route files from a directory.\n *\n * Each file should default-export a Hono app (or router).\n * The filename (without extension) becomes the mount path:\n *   `functions/send-invoice.ts` → mounted at `/send-invoice`\n *\n * This mirrors how `loadCollectionsFromDirectory` works for collections.\n */\nexport async function loadFunctionsFromDirectory(\n    directory: string,\n    importModule: ModuleImporter = nativeDynamicImport\n): Promise<LoadedFunction[]> {\n    const functions: LoadedFunction[] = [];\n    // Aggregate problem files so a broken function surfaces as one loud\n    // summary line, not just a warning buried per-file. We still don't throw:\n    // a single malformed function must not crash server boot.\n    const problems: string[] = [];\n\n    if (!fs.existsSync(directory)) {\n        return functions;\n    }\n\n    const files = fs.readdirSync(directory);\n    for (const file of files) {\n        if (\n            (file.endsWith(\".ts\") || file.endsWith(\".js\")) &&\n            // Dotfiles: notably macOS bsdtar AppleDouble sidecars (`._foo.ts`),\n            // binary blobs that cannot be imported.\n            !file.startsWith(\".\") &&\n            !file.includes(\".test.\") &&\n            !file.endsWith(\".d.ts\") &&\n            file !== \"index.ts\" &&\n            file !== \"index.js\"\n        ) {\n            const filePath = path.join(directory, file);\n            try {\n                const fileUrl = pathToFileURL(filePath).href;\n\n                const mod = await importModule(fileUrl);\n\n                const exported = mod.default;\n\n                if (!exported) {\n                    logger.warn(`[functions] ${file}: no default export. Skipping.`);\n                    problems.push(`${file} (no default export)`);\n                    continue;\n                }\n\n                // Accept a Hono instance — use duck-typing to handle different\n                // Hono versions which may not share the same prototype.\n                if (isHonoLike(exported)) {\n                    const name = path.basename(file, path.extname(file));\n                    functions.push({ name,\napp: exported as Hono });\n                    logger.info(`⚡ Loaded function route: ${name}`);\n                    continue;\n                }\n\n                // Also accept a factory function that returns a Hono instance\n                if (typeof exported === \"function\") {\n                    const result = exported();\n                    if (isHonoLike(result)) {\n                        const name = path.basename(file, path.extname(file));\n                        functions.push({ name,\napp: result as Hono });\n                        logger.info(`⚡ Loaded function route: ${name}`);\n                        continue;\n                    }\n                }\n\n                // Provide actionable diagnostics\n                const exportType = typeof exported;\n                const keys = exported && typeof exported === \"object\"\n                    ? Object.getOwnPropertyNames(Object.getPrototypeOf(exported)).slice(0, 10).join(\", \")\n                    : \"N/A\";\n                logger.warn(\n                    `[functions] ${file}: default export is not a Hono app or factory. Skipping.\\n` +\n                    `  export type: ${exportType}${exported?.constructor?.name ? ` (${exported.constructor.name})` : \"\"}\\n` +\n                    `  prototype methods: ${keys}\\n` +\n                    \"  Hint: ensure the function exports a Hono app created with the same hono version as the server.\\n\" +\n                    \"  Author with `defineFunction(...)` from @rebasepro/server for a typed, checked contract.\\n\" +\n                    \"  The loader checks for .fetch() and .routes — any Hono-compatible app will work.\"\n                );\n                problems.push(`${file} (not a Hono app or factory)`);\n            } catch (err: unknown) {\n                const message =\n                    err instanceof Error ? err.message : String(err);\n                logger.error(`[functions] Failed to load ${file}: ${message}`);\n                problems.push(`${file} (threw: ${message})`);\n            }\n        }\n    }\n\n    if (problems.length > 0) {\n        logger.warn(\n            `[functions] ${problems.length} function file(s) were skipped and will NOT be served:\\n` +\n            problems.map((p) => `  - ${p}`).join(\"\\n\") + \"\\n\" +\n            \"  Fix these or author them with `defineFunction(...)` for a typed, compile-checked contract.\"\n        );\n    }\n\n    return functions;\n}\n\n/**\n * Duck-type check for Hono apps.\n * We avoid `instanceof Hono` because different Hono versions\n * installed in the user's project vs. our dependencies will\n * not share the same prototype, causing false negatives.\n */\nfunction isHonoLike(obj: unknown): boolean {\n    if (!obj || typeof obj !== \"object\") return false;\n    // Hono instances always have .fetch() and .routes\n    const record = obj as Record<string, unknown>;\n    return (\n        typeof record.fetch === \"function\" &&\n        Array.isArray(record.routes)\n    );\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAuBA,eAAsB,2BAClB,WACA,eAA+B,qBACN;CACzB,MAAM,YAA8B,CAAC;CAIrC,MAAM,WAAqB,CAAC;CAE5B,IAAI,CAAC,KAAG,WAAW,SAAS,GACxB,OAAO;CAGX,MAAM,QAAQ,KAAG,YAAY,SAAS;CACtC,KAAK,MAAM,QAAQ,OACf,KACK,KAAK,SAAS,KAAK,KAAK,KAAK,SAAS,KAAK,MAG5C,CAAC,KAAK,WAAW,GAAG,KACpB,CAAC,KAAK,SAAS,QAAQ,KACvB,CAAC,KAAK,SAAS,OAAO,KACtB,SAAS,cACT,SAAS,YACX;EACE,MAAM,WAAW,OAAK,KAAK,WAAW,IAAI;EAC1C,IAAI;GACA,MAAM,UAAU,cAAc,QAAQ,CAAC,CAAC;GAIxC,MAAM,YAAW,MAFC,aAAa,OAAO,EAAA,CAEjB;GAErB,IAAI,CAAC,UAAU;IACX,OAAO,KAAK,eAAe,KAAK,+BAA+B;IAC/D,SAAS,KAAK,GAAG,KAAK,qBAAqB;IAC3C;GACJ;GAIA,IAAI,WAAW,QAAQ,GAAG;IACtB,MAAM,OAAO,OAAK,SAAS,MAAM,OAAK,QAAQ,IAAI,CAAC;IACnD,UAAU,KAAK;KAAE;KACrC,KAAK;IAAiB,CAAC;IACH,OAAO,KAAK,4BAA4B,MAAM;IAC9C;GACJ;GAGA,IAAI,OAAO,aAAa,YAAY;IAChC,MAAM,SAAS,SAAS;IACxB,IAAI,WAAW,MAAM,GAAG;KACpB,MAAM,OAAO,OAAK,SAAS,MAAM,OAAK,QAAQ,IAAI,CAAC;KACnD,UAAU,KAAK;MAAE;MACzC,KAAK;KAAe,CAAC;KACG,OAAO,KAAK,4BAA4B,MAAM;KAC9C;IACJ;GACJ;GAGA,MAAM,aAAa,OAAO;GAC1B,MAAM,OAAO,YAAY,OAAO,aAAa,WACvC,OAAO,oBAAoB,OAAO,eAAe,QAAQ,CAAC,CAAC,CAAC,MAAM,GAAG,EAAE,CAAC,CAAC,KAAK,IAAI,IAClF;GACN,OAAO,KACH,eAAe,KAAK,2EACF,aAAa,UAAU,aAAa,OAAO,KAAK,SAAS,YAAY,KAAK,KAAK,GAAG,yBAC5E,KAAK;;kFAIjC;GACA,SAAS,KAAK,GAAG,KAAK,6BAA6B;EACvD,SAAS,KAAc;GACnB,MAAM,UACF,eAAe,QAAQ,IAAI,UAAU,OAAO,GAAG;GACnD,OAAO,MAAM,8BAA8B,KAAK,IAAI,SAAS;GAC7D,SAAS,KAAK,GAAG,KAAK,WAAW,QAAQ,EAAE;EAC/C;CACJ;CAGJ,IAAI,SAAS,SAAS,GAClB,OAAO,KACH,eAAe,SAAS,OAAO,4DAC/B,SAAS,KAAK,MAAM,OAAO,GAAG,CAAC,CAAC,KAAK,IAAI,IAAI,gGAEjD;CAGJ,OAAO;AACX;;;;;;;AAQA,SAAS,WAAW,KAAuB;CACvC,IAAI,CAAC,OAAO,OAAO,QAAQ,UAAU,OAAO;CAE5C,MAAM,SAAS;CACf,OACI,OAAO,OAAO,UAAU,cACxB,MAAM,QAAQ,OAAO,MAAM;AAEnC"}

package/dist/function-routes-C0cLIy3N.js

@@ -0,0 +1,28 @@
+import { createRequire as __createRequire } from "module";
+import "process";
+__createRequire(import.meta.url);
+import { n as __exportAll } from "./rolldown-runtime-DSJWtz9O.js";
+import { Hono } from "hono";
+//#region src/functions/function-routes.ts
+var function_routes_exports = /* @__PURE__ */ __exportAll({ createFunctionRoutes: () => createFunctionRoutes });
+/**
+* Mount all loaded function routes under a single Hono router.
+*
+* Each function is mounted at `/<function-name>`, preserving
+* whatever HTTP methods and middleware the Hono sub-app defines.
+*/
+function createFunctionRoutes(functions) {
+	const router = new Hono();
+	router.get("/", (c) => {
+		return c.json({ functions: functions.map((fn) => ({
+			name: fn.name,
+			endpoint: `/functions/${fn.name}`
+		})) });
+	});
+	for (const fn of functions) router.route(`/${fn.name}`, fn.app);
+	return router;
+}
+//#endregion
+export { function_routes_exports as n, createFunctionRoutes as t };
+
+//# sourceMappingURL=function-routes-C0cLIy3N.js.map

package/dist/function-routes-C0cLIy3N.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"function-routes-C0cLIy3N.js","names":[],"sources":["../src/functions/function-routes.ts"],"sourcesContent":["import { Hono } from \"hono\";\nimport { HonoEnv } from \"../api/types\";\nimport { LoadedFunction } from \"./function-loader\";\n\n/**\n * Mount all loaded function routes under a single Hono router.\n *\n * Each function is mounted at `/<function-name>`, preserving\n * whatever HTTP methods and middleware the Hono sub-app defines.\n */\nexport function createFunctionRoutes(\n    functions: LoadedFunction[]\n): Hono<HonoEnv> {\n    const router = new Hono<HonoEnv>();\n\n    // Listing endpoint: GET / → list available functions\n    router.get(\"/\", (c) => {\n        return c.json({\n            functions: functions.map((fn) => ({\n                name: fn.name,\n                endpoint: `/functions/${fn.name}`\n            }))\n        });\n    });\n\n    for (const fn of functions) {\n        router.route(`/${fn.name}`, fn.app);\n    }\n\n    return router;\n}\n"],"mappings":";;;;;;;;;;;;;AAUA,SAAgB,qBACZ,WACa;CACb,MAAM,SAAS,IAAI,KAAc;CAGjC,OAAO,IAAI,MAAM,MAAM;EACnB,OAAO,EAAE,KAAK,EACV,WAAW,UAAU,KAAK,QAAQ;GAC9B,MAAM,GAAG;GACT,UAAU,cAAc,GAAG;EAC/B,EAAE,EACN,CAAC;CACL,CAAC;CAED,KAAK,MAAM,MAAM,WACb,OAAO,MAAM,IAAI,GAAG,QAAQ,GAAG,GAAG;CAGtC,OAAO;AACX"}