frappe-nextjs 0.1.0

package/dist/hooks/useFrappeFileUpload.js

@@ -0,0 +1,68 @@
+"use strict";
+'use client';
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useFrappeFileUpload = useFrappeFileUpload;
+const react_1 = require("react");
+const FrappeProvider_1 = require("./FrappeProvider");
+/**
+ * Hook to upload files to Frappe with progress tracking.
+ *
+ * @example
+ * ```tsx
+ * function FileUploader({ doctype, docname }: { doctype: string; docname: string }) {
+ *   const { upload, isUploading, progress, result, error, reset } = useFrappeFileUpload();
+ *
+ *   const handleChange = (e: React.ChangeEvent<HTMLInputElement>) => {
+ *     const file = e.target.files?.[0];
+ *     if (file) {
+ *       upload({ file, doctype, docname, isPrivate: true });
+ *     }
+ *   };
+ *
+ *   return (
+ *     <div>
+ *       <input type="file" onChange={handleChange} disabled={isUploading} />
+ *       {isUploading && <progress value={progress} max={100} />}
+ *       {result && <a href={result.file_url}>Uploaded: {result.file_name}</a>}
+ *       {error && <p>Error: {error.message}</p>}
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+function useFrappeFileUpload() {
+    const client = (0, FrappeProvider_1.useFrappeClient)();
+    const [state, setState] = (0, react_1.useState)({
+        isUploading: false,
+        progress: 0,
+        error: null,
+        result: null,
+    });
+    const upload = (0, react_1.useCallback)(async (options) => {
+        setState({ isUploading: true, progress: 0, error: null, result: null });
+        try {
+            const result = await client.uploadFile({
+                ...options,
+                onProgress: (progress) => {
+                    setState((prev) => ({ ...prev, progress }));
+                },
+            });
+            setState({ isUploading: false, progress: 100, error: null, result });
+            return result;
+        }
+        catch (err) {
+            const error = err;
+            setState((prev) => ({ ...prev, isUploading: false, error }));
+            throw error;
+        }
+    }, [client]);
+    const reset = (0, react_1.useCallback)(() => {
+        setState({ isUploading: false, progress: 0, error: null, result: null });
+    }, []);
+    return {
+        upload,
+        reset,
+        ...state,
+    };
+}
+//# sourceMappingURL=useFrappeFileUpload.js.map

package/dist/hooks/useFrappeFileUpload.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useFrappeFileUpload.js","sourceRoot":"","sources":["../../src/hooks/useFrappeFileUpload.ts"],"names":[],"mappings":";AAAA,YAAY,CAAC;;AA2Cb,kDA0CC;AAnFD,iCAA8C;AAC9C,qDAAmD;AAcnD;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,SAAgB,mBAAmB;IACjC,MAAM,MAAM,GAAG,IAAA,gCAAe,GAAE,CAAC;IAEjC,MAAM,CAAC,KAAK,EAAE,QAAQ,CAAC,GAAG,IAAA,gBAAQ,EAAc;QAC9C,WAAW,EAAE,KAAK;QAClB,QAAQ,EAAE,CAAC;QACX,KAAK,EAAE,IAAI;QACX,MAAM,EAAE,IAAI;KACb,CAAC,CAAC;IAEH,MAAM,MAAM,GAAG,IAAA,mBAAW,EACxB,KAAK,EAAE,OAA8C,EAAE,EAAE;QACvD,QAAQ,CAAC,EAAE,WAAW,EAAE,IAAI,EAAE,QAAQ,EAAE,CAAC,EAAE,KAAK,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC,CAAC;QAExE,IAAI,CAAC;YACH,MAAM,MAAM,GAAG,MAAM,MAAM,CAAC,UAAU,CAAC;gBACrC,GAAG,OAAO;gBACV,UAAU,EAAE,CAAC,QAAQ,EAAE,EAAE;oBACvB,QAAQ,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC,EAAE,GAAG,IAAI,EAAE,QAAQ,EAAE,CAAC,CAAC,CAAC;gBAC9C,CAAC;aACF,CAAC,CAAC;YAEH,QAAQ,CAAC,EAAE,WAAW,EAAE,KAAK,EAAE,QAAQ,EAAE,GAAG,EAAE,KAAK,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC,CAAC;YACrE,OAAO,MAAM,CAAC;QAChB,CAAC;QAAC,OAAO,GAAG,EAAE,CAAC;YACb,MAAM,KAAK,GAAG,GAAY,CAAC;YAC3B,QAAQ,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC,EAAE,GAAG,IAAI,EAAE,WAAW,EAAE,KAAK,EAAE,KAAK,EAAE,CAAC,CAAC,CAAC;YAC7D,MAAM,KAAK,CAAC;QACd,CAAC;IACH,CAAC,EACD,CAAC,MAAM,CAAC,CACT,CAAC;IAEF,MAAM,KAAK,GAAG,IAAA,mBAAW,EAAC,GAAG,EAAE;QAC7B,QAAQ,CAAC,EAAE,WAAW,EAAE,KAAK,EAAE,QAAQ,EAAE,CAAC,EAAE,KAAK,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC,CAAC;IAC3E,CAAC,EAAE,EAAE,CAAC,CAAC;IAEP,OAAO;QACL,MAAM;QACN,KAAK;QACL,GAAG,KAAK;KACT,CAAC;AACJ,CAAC"}

package/dist/index.d.ts

@@ -0,0 +1,10 @@
+export { FrappeClient } from './client/FrappeClient';
+export type { FrappeClientConfig, FrappeDoc, FrappeDocBase, FrappeResponse, FrappeApiError, Filter, FilterOperator, OrderBy, GetDocListParams, GetDocParams, CreateDocParams, UpdateDocParams, CallParams, FileUploadOptions, FileUploadResponse, AuthState, LoginCredentials, } from './client/types';
+export { FrappeProvider, useFrappeClient, } from './hooks/FrappeProvider';
+export type { FrappeProviderProps } from './hooks/FrappeProvider';
+export { useFrappeCall } from './hooks/useFrappeCall';
+export { useFrappeDocList } from './hooks/useFrappeDocList';
+export { useFrappeDoc } from './hooks/useFrappeDoc';
+export { useFrappeAuth } from './hooks/useFrappeAuth';
+export { useFrappeFileUpload } from './hooks/useFrappeFileUpload';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AACrD,YAAY,EACV,kBAAkB,EAClB,SAAS,EACT,aAAa,EACb,cAAc,EACd,cAAc,EACd,MAAM,EACN,cAAc,EACd,OAAO,EACP,gBAAgB,EAChB,YAAY,EACZ,eAAe,EACf,eAAe,EACf,UAAU,EACV,iBAAiB,EACjB,kBAAkB,EAClB,SAAS,EACT,gBAAgB,GACjB,MAAM,gBAAgB,CAAC;AAGxB,OAAO,EACL,cAAc,EACd,eAAe,GAChB,MAAM,wBAAwB,CAAC;AAChC,YAAY,EAAE,mBAAmB,EAAE,MAAM,wBAAwB,CAAC;AAClE,OAAO,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AACtD,OAAO,EAAE,gBAAgB,EAAE,MAAM,0BAA0B,CAAC;AAC5D,OAAO,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AACpD,OAAO,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AACtD,OAAO,EAAE,mBAAmB,EAAE,MAAM,6BAA6B,CAAC"}

package/dist/index.js

@@ -0,0 +1,24 @@
+"use strict";
+// ─── Main exports for frappe-nextjs ────────────────────────────────
+// NOTE: This is the client-safe entry point. Do NOT import server-only
+// modules here (fs, path, etc). Server utilities live in 'frappe-nextjs/ssr'.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useFrappeFileUpload = exports.useFrappeAuth = exports.useFrappeDoc = exports.useFrappeDocList = exports.useFrappeCall = exports.useFrappeClient = exports.FrappeProvider = exports.FrappeClient = void 0;
+// Client
+var FrappeClient_1 = require("./client/FrappeClient");
+Object.defineProperty(exports, "FrappeClient", { enumerable: true, get: function () { return FrappeClient_1.FrappeClient; } });
+// Hooks
+var FrappeProvider_1 = require("./hooks/FrappeProvider");
+Object.defineProperty(exports, "FrappeProvider", { enumerable: true, get: function () { return FrappeProvider_1.FrappeProvider; } });
+Object.defineProperty(exports, "useFrappeClient", { enumerable: true, get: function () { return FrappeProvider_1.useFrappeClient; } });
+var useFrappeCall_1 = require("./hooks/useFrappeCall");
+Object.defineProperty(exports, "useFrappeCall", { enumerable: true, get: function () { return useFrappeCall_1.useFrappeCall; } });
+var useFrappeDocList_1 = require("./hooks/useFrappeDocList");
+Object.defineProperty(exports, "useFrappeDocList", { enumerable: true, get: function () { return useFrappeDocList_1.useFrappeDocList; } });
+var useFrappeDoc_1 = require("./hooks/useFrappeDoc");
+Object.defineProperty(exports, "useFrappeDoc", { enumerable: true, get: function () { return useFrappeDoc_1.useFrappeDoc; } });
+var useFrappeAuth_1 = require("./hooks/useFrappeAuth");
+Object.defineProperty(exports, "useFrappeAuth", { enumerable: true, get: function () { return useFrappeAuth_1.useFrappeAuth; } });
+var useFrappeFileUpload_1 = require("./hooks/useFrappeFileUpload");
+Object.defineProperty(exports, "useFrappeFileUpload", { enumerable: true, get: function () { return useFrappeFileUpload_1.useFrappeFileUpload; } });
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";AAAA,sEAAsE;AACtE,uEAAuE;AACvE,8EAA8E;;;AAE9E,SAAS;AACT,sDAAqD;AAA5C,4GAAA,YAAY,OAAA;AAqBrB,QAAQ;AACR,yDAGgC;AAF9B,gHAAA,cAAc,OAAA;AACd,iHAAA,eAAe,OAAA;AAGjB,uDAAsD;AAA7C,8GAAA,aAAa,OAAA;AACtB,6DAA4D;AAAnD,oHAAA,gBAAgB,OAAA;AACzB,qDAAoD;AAA3C,4GAAA,YAAY,OAAA;AACrB,uDAAsD;AAA7C,8GAAA,aAAa,OAAA;AACtB,mEAAkE;AAAzD,0HAAA,mBAAmB,OAAA"}

package/dist/ssr/index.d.ts

@@ -0,0 +1,4 @@
+export { createServerClient, createRequestClient } from './server-client';
+export { generateRewrites, generateNextConfig } from './proxy-config';
+export { generateProxy, generateMiddleware } from './middleware';
+//# sourceMappingURL=index.d.ts.map

package/dist/ssr/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/ssr/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,mBAAmB,EAAE,MAAM,iBAAiB,CAAC;AAC1E,OAAO,EAAE,gBAAgB,EAAE,kBAAkB,EAAE,MAAM,gBAAgB,CAAC;AACtE,OAAO,EAAE,aAAa,EAAE,kBAAkB,EAAE,MAAM,cAAc,CAAC"}

package/dist/ssr/index.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateMiddleware = exports.generateProxy = exports.generateNextConfig = exports.generateRewrites = exports.createRequestClient = exports.createServerClient = void 0;
+var server_client_1 = require("./server-client");
+Object.defineProperty(exports, "createServerClient", { enumerable: true, get: function () { return server_client_1.createServerClient; } });
+Object.defineProperty(exports, "createRequestClient", { enumerable: true, get: function () { return server_client_1.createRequestClient; } });
+var proxy_config_1 = require("./proxy-config");
+Object.defineProperty(exports, "generateRewrites", { enumerable: true, get: function () { return proxy_config_1.generateRewrites; } });
+Object.defineProperty(exports, "generateNextConfig", { enumerable: true, get: function () { return proxy_config_1.generateNextConfig; } });
+var middleware_1 = require("./middleware");
+Object.defineProperty(exports, "generateProxy", { enumerable: true, get: function () { return middleware_1.generateProxy; } });
+Object.defineProperty(exports, "generateMiddleware", { enumerable: true, get: function () { return middleware_1.generateMiddleware; } });
+//# sourceMappingURL=index.js.map

package/dist/ssr/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/ssr/index.ts"],"names":[],"mappings":";;;AAAA,iDAA0E;AAAjE,mHAAA,kBAAkB,OAAA;AAAE,oHAAA,mBAAmB,OAAA;AAChD,+CAAsE;AAA7D,gHAAA,gBAAgB,OAAA;AAAE,kHAAA,kBAAkB,OAAA;AAC7C,2CAAiE;AAAxD,2GAAA,aAAa,OAAA;AAAE,gHAAA,kBAAkB,OAAA"}

package/dist/ssr/middleware.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Generates Next.js 16+ proxy.ts code for Frappe integration.
+ *
+ * In Next.js 16, `middleware.ts` has been renamed to `proxy.ts`.
+ * The proxy intercepts requests to protected routes and checks
+ * if the user has valid Frappe session cookies. It also handles
+ * proxying API requests to the Frappe backend.
+ *
+ * For Next.js 14/15, use `generateMiddleware()` instead.
+ */
+export declare function generateProxy(spaName: string, frappePort?: number): string;
+/**
+ * Generates Next.js 14/15 middleware.ts code (legacy, still works in Next.js 16).
+ *
+ * For Next.js 16+, prefer `generateProxy()` which uses the new proxy.ts convention.
+ */
+export declare function generateMiddleware(spaName: string): string;
+//# sourceMappingURL=middleware.d.ts.map

package/dist/ssr/middleware.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"middleware.d.ts","sourceRoot":"","sources":["../../src/ssr/middleware.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,wBAAgB,aAAa,CAAC,OAAO,EAAE,MAAM,EAAE,UAAU,GAAE,MAAa,GAAG,MAAM,CAoEhF;AAED;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CA0C1D"}

package/dist/ssr/middleware.js

@@ -0,0 +1,132 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateProxy = generateProxy;
+exports.generateMiddleware = generateMiddleware;
+/**
+ * Generates Next.js 16+ proxy.ts code for Frappe integration.
+ *
+ * In Next.js 16, `middleware.ts` has been renamed to `proxy.ts`.
+ * The proxy intercepts requests to protected routes and checks
+ * if the user has valid Frappe session cookies. It also handles
+ * proxying API requests to the Frappe backend.
+ *
+ * For Next.js 14/15, use `generateMiddleware()` instead.
+ */
+function generateProxy(spaName, frappePort = 8000) {
+    return `import { NextResponse } from 'next/server';
+import type { NextRequest } from 'next/server';
+
+/**
+ * Proxy to handle Frappe API proxying and authentication for Next.js 16+ routes.
+ *
+ * - Proxies /api/*, /assets/*, /files/* to the Frappe backend
+ * - Checks for 'user_id' cookie set by Frappe
+ * - Redirects unauthenticated users to Frappe login
+ */
+export function proxy(request: NextRequest) {
+  const { pathname } = request.nextUrl;
+  const frappeUrl = process.env.FRAPPE_URL || 'http://127.0.0.1:${frappePort}';
+
+  // ─── Proxy Frappe API/assets/files requests ─────────────────────
+  const proxyPrefixes = ['/api/', '/assets/', '/files/', '/socket.io/'];
+  const shouldProxy = proxyPrefixes.some((prefix) => pathname.startsWith(prefix));
+
+  if (shouldProxy) {
+    const url = new URL(pathname + request.nextUrl.search, frappeUrl);
+    return NextResponse.rewrite(url, {
+      headers: request.headers,
+    });
+  }
+
+  // ─── Auth guard for SPA routes ─────────────────────────────────
+  const userId = request.cookies.get('user_id')?.value;
+  const isGuest = !userId || userId === 'Guest';
+
+  // Define public paths that don't require authentication
+  const publicPaths = ['/${spaName}/login', '/${spaName}/signup'];
+  const isPublicPath = publicPaths.some((p) =>
+    pathname.startsWith(p)
+  );
+
+  // Only guard /${spaName}/* routes
+  const isSpaRoute = pathname.startsWith('/${spaName}');
+
+  if (isSpaRoute) {
+    // Redirect unauthenticated users to login
+    if (isGuest && !isPublicPath) {
+      const loginUrl = new URL('/login', request.url);
+      loginUrl.searchParams.set('redirect-to', pathname);
+      return NextResponse.redirect(loginUrl);
+    }
+
+    // If logged in and trying to access login page, redirect to home
+    if (!isGuest && isPublicPath) {
+      return NextResponse.redirect(new URL('/${spaName}', request.url));
+    }
+  }
+
+  return NextResponse.next();
+}
+
+export const config = {
+  matcher: [
+    // Proxy Frappe API routes
+    '/api/:path*',
+    '/assets/:path*',
+    '/files/:path*',
+    '/socket.io/:path*',
+    // Guard SPA routes
+    '/${spaName}/:path*',
+  ],
+};
+`;
+}
+/**
+ * Generates Next.js 14/15 middleware.ts code (legacy, still works in Next.js 16).
+ *
+ * For Next.js 16+, prefer `generateProxy()` which uses the new proxy.ts convention.
+ */
+function generateMiddleware(spaName) {
+    return `import { NextResponse } from 'next/server';
+import type { NextRequest } from 'next/server';
+
+/**
+ * Middleware to handle Frappe authentication for Next.js routes.
+ * NOTE: For Next.js 16+, consider using proxy.ts instead (see generateProxy).
+ *
+ * - Checks for 'user_id' cookie set by Frappe
+ * - Redirects unauthenticated users to Frappe login
+ * - Forwards all cookies to API routes for per-user SSR
+ */
+export function middleware(request: NextRequest) {
+  const userId = request.cookies.get('user_id')?.value;
+  const isGuest = !userId || userId === 'Guest';
+
+  // Define public paths that don't require authentication
+  const publicPaths = ['/${spaName}/login', '/${spaName}/signup'];
+  const isPublicPath = publicPaths.some((path) =>
+    request.nextUrl.pathname.startsWith(path)
+  );
+
+  // Redirect unauthenticated users to login
+  if (isGuest && !isPublicPath) {
+    const loginUrl = new URL('/login', request.url);
+    loginUrl.searchParams.set('redirect-to', request.nextUrl.pathname);
+    return NextResponse.redirect(loginUrl);
+  }
+
+  // If logged in and trying to access login page, redirect to home
+  if (!isGuest && isPublicPath) {
+    return NextResponse.redirect(new URL('/${spaName}', request.url));
+  }
+
+  return NextResponse.next();
+}
+
+export const config = {
+  // Apply middleware to all routes under /${spaName} except static assets
+  matcher: ['/${spaName}/:path*'],
+};
+`;
+}
+//# sourceMappingURL=middleware.js.map

package/dist/ssr/middleware.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"middleware.js","sourceRoot":"","sources":["../../src/ssr/middleware.ts"],"names":[],"mappings":";;AAUA,sCAoEC;AAOD,gDA0CC;AA/HD;;;;;;;;;GASG;AACH,SAAgB,aAAa,CAAC,OAAe,EAAE,aAAqB,IAAI;IACtE,OAAO;;;;;;;;;;;;kEAYyD,UAAU;;;;;;;;;;;;;;;;;;2BAkBjD,OAAO,cAAc,OAAO;;;;;mBAKpC,OAAO;6CACmB,OAAO;;;;;;;;;;;;+CAYL,OAAO;;;;;;;;;;;;;;;QAe9C,OAAO;;;CAGd,CAAC;AACF,CAAC;AAED;;;;GAIG;AACH,SAAgB,kBAAkB,CAAC,OAAe;IAChD,OAAO;;;;;;;;;;;;;;;;2BAgBkB,OAAO,cAAc,OAAO;;;;;;;;;;;;;;6CAcV,OAAO;;;;;;;6CAOP,OAAO;gBACpC,OAAO;;CAEtB,CAAC;AACF,CAAC"}

package/dist/ssr/proxy-config.d.ts

@@ -0,0 +1,33 @@
+interface ProxyConfigOptions {
+    /** Path to bench's sites/common_site_config.json */
+    benchPath?: string;
+    /** Override Frappe webserver port (default: read from config or 8000) */
+    frappePort?: number;
+}
+/**
+ * Generate Next.js rewrite rules to proxy Frappe API requests during development.
+ *
+ * @example
+ * ```ts
+ * // next.config.mjs
+ * import { generateRewrites } from 'frappe-nextjs/ssr';
+ *
+ * const nextConfig = {
+ *   async rewrites() {
+ *     return generateRewrites({ frappePort: 8000 });
+ *   },
+ * };
+ *
+ * export default nextConfig;
+ * ```
+ */
+export declare function generateRewrites(options?: ProxyConfigOptions): {
+    source: string;
+    destination: string;
+}[];
+/**
+ * Generate a complete next.config.mjs string with Frappe proxy rewrites.
+ */
+export declare function generateNextConfig(spaName: string, mode: 'ssr' | 'static', frappePort?: number): string;
+export {};
+//# sourceMappingURL=proxy-config.d.ts.map

package/dist/ssr/proxy-config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"proxy-config.d.ts","sourceRoot":"","sources":["../../src/ssr/proxy-config.ts"],"names":[],"mappings":"AAGA,UAAU,kBAAkB;IAC1B,oDAAoD;IACpD,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,yEAAyE;IACzE,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,GAAE,kBAAuB;;;IAwChE;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAChC,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,KAAK,GAAG,QAAQ,EACtB,UAAU,GAAE,MAAa,GACxB,MAAM,CAkCR"}

package/dist/ssr/proxy-config.js

@@ -0,0 +1,133 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateRewrites = generateRewrites;
+exports.generateNextConfig = generateNextConfig;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+/**
+ * Generate Next.js rewrite rules to proxy Frappe API requests during development.
+ *
+ * @example
+ * ```ts
+ * // next.config.mjs
+ * import { generateRewrites } from 'frappe-nextjs/ssr';
+ *
+ * const nextConfig = {
+ *   async rewrites() {
+ *     return generateRewrites({ frappePort: 8000 });
+ *   },
+ * };
+ *
+ * export default nextConfig;
+ * ```
+ */
+function generateRewrites(options = {}) {
+    let frappePort = options.frappePort || 8000;
+    // Try to read port from bench config
+    if (!options.frappePort && options.benchPath) {
+        try {
+            const configPath = path.join(options.benchPath, 'sites', 'common_site_config.json');
+            const config = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+            if (config.webserver_port) {
+                frappePort = config.webserver_port;
+            }
+        }
+        catch {
+            // Use default port
+        }
+    }
+    const destination = `http://127.0.0.1:${frappePort}`;
+    return [
+        {
+            source: '/api/:path*',
+            destination: `${destination}/api/:path*`,
+        },
+        {
+            source: '/assets/:path*',
+            destination: `${destination}/assets/:path*`,
+        },
+        {
+            source: '/files/:path*',
+            destination: `${destination}/files/:path*`,
+        },
+        {
+            source: '/private/files/:path*',
+            destination: `${destination}/private/files/:path*`,
+        },
+        {
+            source: '/socket.io/:path*',
+            destination: `${destination}/socket.io/:path*`,
+        },
+    ];
+}
+/**
+ * Generate a complete next.config.mjs string with Frappe proxy rewrites.
+ */
+function generateNextConfig(spaName, mode, frappePort = 8000) {
+    const outputConfig = mode === 'static'
+        ? `output: 'export',`
+        : `output: 'standalone',`;
+    return `import { dirname } from 'path';
+import { fileURLToPath } from 'url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+/** @type {import('next').NextConfig} */
+const nextConfig = {
+  ${outputConfig}
+  basePath: '/${spaName}',
+  trailingSlash: true,
+
+  turbopack: {
+    root: __dirname,
+  },
+
+  async rewrites() {
+    const frappeUrl = process.env.FRAPPE_URL || 'http://127.0.0.1:${frappePort}';
+
+    return [
+      { source: '/api/:path*', destination: \`\${frappeUrl}/api/:path*\` },
+      { source: '/assets/:path*', destination: \`\${frappeUrl}/assets/:path*\` },
+      { source: '/files/:path*', destination: \`\${frappeUrl}/files/:path*\` },
+      { source: '/socket.io/:path*', destination: \`\${frappeUrl}/socket.io/:path*\` },
+    ];
+  },
+};
+
+export default nextConfig;
+`;
+}
+//# sourceMappingURL=proxy-config.js.map

package/dist/ssr/proxy-config.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"proxy-config.js","sourceRoot":"","sources":["../../src/ssr/proxy-config.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2BA,4CAwCC;AAKD,gDAsCC;AA9GD,uCAAyB;AACzB,2CAA6B;AAS7B;;;;;;;;;;;;;;;;GAgBG;AACH,SAAgB,gBAAgB,CAAC,UAA8B,EAAE;IAC/D,IAAI,UAAU,GAAG,OAAO,CAAC,UAAU,IAAI,IAAI,CAAC;IAE5C,qCAAqC;IACrC,IAAI,CAAC,OAAO,CAAC,UAAU,IAAI,OAAO,CAAC,SAAS,EAAE,CAAC;QAC7C,IAAI,CAAC;YACH,MAAM,UAAU,GAAG,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,SAAS,EAAE,OAAO,EAAE,yBAAyB,CAAC,CAAC;YACpF,MAAM,MAAM,GAAG,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC,YAAY,CAAC,UAAU,EAAE,OAAO,CAAC,CAAC,CAAC;YAChE,IAAI,MAAM,CAAC,cAAc,EAAE,CAAC;gBAC1B,UAAU,GAAG,MAAM,CAAC,cAAc,CAAC;YACrC,CAAC;QACH,CAAC;QAAC,MAAM,CAAC;YACP,mBAAmB;QACrB,CAAC;IACH,CAAC;IAED,MAAM,WAAW,GAAG,oBAAoB,UAAU,EAAE,CAAC;IAErD,OAAO;QACL;YACE,MAAM,EAAE,aAAa;YACrB,WAAW,EAAE,GAAG,WAAW,aAAa;SACzC;QACD;YACE,MAAM,EAAE,gBAAgB;YACxB,WAAW,EAAE,GAAG,WAAW,gBAAgB;SAC5C;QACD;YACE,MAAM,EAAE,eAAe;YACvB,WAAW,EAAE,GAAG,WAAW,eAAe;SAC3C;QACD;YACE,MAAM,EAAE,uBAAuB;YAC/B,WAAW,EAAE,GAAG,WAAW,uBAAuB;SACnD;QACD;YACE,MAAM,EAAE,mBAAmB;YAC3B,WAAW,EAAE,GAAG,WAAW,mBAAmB;SAC/C;KACF,CAAC;AACJ,CAAC;AAED;;GAEG;AACH,SAAgB,kBAAkB,CAChC,OAAe,EACf,IAAsB,EACtB,aAAqB,IAAI;IAEzB,MAAM,YAAY,GAAG,IAAI,KAAK,QAAQ;QACpC,CAAC,CAAC,mBAAmB;QACrB,CAAC,CAAC,uBAAuB,CAAC;IAE5B,OAAO;;;;;;;IAOL,YAAY;gBACA,OAAO;;;;;;;;oEAQ6C,UAAU;;;;;;;;;;;;CAY7E,CAAC;AACF,CAAC"}

package/dist/ssr/server-client.d.ts

@@ -0,0 +1,73 @@
+import { FrappeClient } from '../client/FrappeClient';
+import { FrappeClientConfig } from '../client/types';
+/**
+ * Create a Frappe client configured for server-side usage in Next.js.
+ *
+ * Uses token-based authentication (API Key + Secret) since cookies are
+ * not available in Server Components, Route Handlers, or Server Actions.
+ *
+ * @example
+ * ```ts
+ * // lib/frappe.ts
+ * import { createServerClient } from 'frappe-nextjs/ssr';
+ *
+ * export const frappe = createServerClient({
+ *   baseUrl: process.env.FRAPPE_URL!,
+ *   token: {
+ *     apiKey: process.env.FRAPPE_API_KEY!,
+ *     apiSecret: process.env.FRAPPE_API_SECRET!,
+ *   },
+ * });
+ * ```
+ *
+ * @example
+ * ```tsx
+ * // app/todos/page.tsx (Server Component)
+ * import { frappe } from '@/lib/frappe';
+ *
+ * export default async function TodosPage() {
+ *   const todos = await frappe.getDocList({
+ *     doctype: 'ToDo',
+ *     fields: ['name', 'description', 'status'],
+ *     limit: 20,
+ *   });
+ *
+ *   return (
+ *     <ul>
+ *       {todos.map((todo) => (
+ *         <li key={todo.name}>{todo.description}</li>
+ *       ))}
+ *     </ul>
+ *   );
+ * }
+ * ```
+ */
+export declare function createServerClient(config: FrappeClientConfig): FrappeClient;
+/**
+ * Create a Frappe client that forwards cookies from the incoming request.
+ * Useful for per-user SSR where you want to fetch data as the logged-in user.
+ *
+ * @example
+ * ```ts
+ * // app/api/user-data/route.ts
+ * import { createRequestClient } from 'frappe-nextjs/ssr';
+ * import { cookies } from 'next/headers';
+ *
+ * export async function GET() {
+ *   const cookieStore = cookies();
+ *   const client = createRequestClient({
+ *     baseUrl: process.env.FRAPPE_URL!,
+ *     cookies: cookieStore.toString(),
+ *   });
+ *
+ *   const user = await client.getLoggedUser();
+ *   return Response.json({ user });
+ * }
+ * ```
+ */
+export declare function createRequestClient(config: {
+    baseUrl: string;
+    cookies: string;
+    fetchImpl?: typeof fetch;
+}): FrappeClient;
+//# sourceMappingURL=server-client.d.ts.map

package/dist/ssr/server-client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"server-client.d.ts","sourceRoot":"","sources":["../../src/ssr/server-client.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAC;AACtD,OAAO,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAC;AAErD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,kBAAkB,GAAG,YAAY,CAoB3E;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE;IAC1C,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,CAAC,EAAE,OAAO,KAAK,CAAC;CAC1B,GAAG,YAAY,CAQf"}

package/dist/ssr/server-client.js

@@ -0,0 +1,94 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createServerClient = createServerClient;
+exports.createRequestClient = createRequestClient;
+const FrappeClient_1 = require("../client/FrappeClient");
+/**
+ * Create a Frappe client configured for server-side usage in Next.js.
+ *
+ * Uses token-based authentication (API Key + Secret) since cookies are
+ * not available in Server Components, Route Handlers, or Server Actions.
+ *
+ * @example
+ * ```ts
+ * // lib/frappe.ts
+ * import { createServerClient } from 'frappe-nextjs/ssr';
+ *
+ * export const frappe = createServerClient({
+ *   baseUrl: process.env.FRAPPE_URL!,
+ *   token: {
+ *     apiKey: process.env.FRAPPE_API_KEY!,
+ *     apiSecret: process.env.FRAPPE_API_SECRET!,
+ *   },
+ * });
+ * ```
+ *
+ * @example
+ * ```tsx
+ * // app/todos/page.tsx (Server Component)
+ * import { frappe } from '@/lib/frappe';
+ *
+ * export default async function TodosPage() {
+ *   const todos = await frappe.getDocList({
+ *     doctype: 'ToDo',
+ *     fields: ['name', 'description', 'status'],
+ *     limit: 20,
+ *   });
+ *
+ *   return (
+ *     <ul>
+ *       {todos.map((todo) => (
+ *         <li key={todo.name}>{todo.description}</li>
+ *       ))}
+ *     </ul>
+ *   );
+ * }
+ * ```
+ */
+function createServerClient(config) {
+    if (!config.baseUrl) {
+        throw new Error('createServerClient requires a baseUrl. ' +
+            'Set FRAPPE_URL in your environment variables.');
+    }
+    if (!config.token) {
+        throw new Error('createServerClient requires token auth (apiKey + apiSecret). ' +
+            'Set FRAPPE_API_KEY and FRAPPE_API_SECRET in your environment variables.');
+    }
+    return new FrappeClient_1.FrappeClient({
+        ...config,
+        // Use global fetch in Node.js (available in Node 18+)
+        fetchImpl: config.fetchImpl || globalThis.fetch.bind(globalThis),
+    });
+}
+/**
+ * Create a Frappe client that forwards cookies from the incoming request.
+ * Useful for per-user SSR where you want to fetch data as the logged-in user.
+ *
+ * @example
+ * ```ts
+ * // app/api/user-data/route.ts
+ * import { createRequestClient } from 'frappe-nextjs/ssr';
+ * import { cookies } from 'next/headers';
+ *
+ * export async function GET() {
+ *   const cookieStore = cookies();
+ *   const client = createRequestClient({
+ *     baseUrl: process.env.FRAPPE_URL!,
+ *     cookies: cookieStore.toString(),
+ *   });
+ *
+ *   const user = await client.getLoggedUser();
+ *   return Response.json({ user });
+ * }
+ * ```
+ */
+function createRequestClient(config) {
+    return new FrappeClient_1.FrappeClient({
+        baseUrl: config.baseUrl,
+        headers: {
+            Cookie: config.cookies,
+        },
+        fetchImpl: config.fetchImpl || globalThis.fetch.bind(globalThis),
+    });
+}
+//# sourceMappingURL=server-client.js.map

package/dist/ssr/server-client.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"server-client.js","sourceRoot":"","sources":["../../src/ssr/server-client.ts"],"names":[],"mappings":";;AA6CA,gDAoBC;AAwBD,kDAYC;AArGD,yDAAsD;AAGtD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AACH,SAAgB,kBAAkB,CAAC,MAA0B;IAC3D,IAAI,CAAC,MAAM,CAAC,OAAO,EAAE,CAAC;QACpB,MAAM,IAAI,KAAK,CACb,yCAAyC;YACzC,+CAA+C,CAChD,CAAC;IACJ,CAAC;IAED,IAAI,CAAC,MAAM,CAAC,KAAK,EAAE,CAAC;QAClB,MAAM,IAAI,KAAK,CACb,+DAA+D;YAC/D,yEAAyE,CAC1E,CAAC;IACJ,CAAC;IAED,OAAO,IAAI,2BAAY,CAAC;QACtB,GAAG,MAAM;QACT,sDAAsD;QACtD,SAAS,EAAE,MAAM,CAAC,SAAS,IAAI,UAAU,CAAC,KAAK,CAAC,IAAI,CAAC,UAAU,CAAC;KACjE,CAAC,CAAC;AACL,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,SAAgB,mBAAmB,CAAC,MAInC;IACC,OAAO,IAAI,2BAAY,CAAC;QACtB,OAAO,EAAE,MAAM,CAAC,OAAO;QACvB,OAAO,EAAE;YACP,MAAM,EAAE,MAAM,CAAC,OAAO;SACvB;QACD,SAAS,EAAE,MAAM,CAAC,SAAS,IAAI,UAAU,CAAC,KAAK,CAAC,IAAI,CAAC,UAAU,CAAC;KACjE,CAAC,CAAC;AACL,CAAC"}