optimized local api instantiation to prepare for nextjs app router

app/build.ts

@@ -56,7 +56,7 @@ async function buildApi() {
       watch,
       entry: ["src/index.ts", "src/data/index.ts", "src/core/index.ts", "src/core/utils/index.ts"],
       outDir: "dist",
-      external: ["bun:test", "@libsql/client", "bknd/client"],
+      external: ["bun:test", "@libsql/client"],
       metafile: true,
       platform: "browser",
       format: ["esm"],

app/src/App.ts

@@ -1,5 +1,5 @@
+import { Api, type ApiOptions } from "Api";
 import type { CreateUserPayload } from "auth/AppAuth";
-import { Api, type ApiOptions } from "bknd/client";
 import { $console } from "core";
 import { Event } from "core/events";
 import { Connection, type LibSqlCredentials, LibsqlConnection } from "data";
@@ -48,6 +48,7 @@ export type CreateAppConfig = {
 };
 
 export type AppConfig = InitialModuleConfigs;
+export type LocalApiOptions = Request | ApiOptions;
 
 export class App {
    modules: ModuleManager;
@@ -180,13 +181,15 @@ export class App {
       return this.module.auth.createUser(p);
    }
 
-   getApi(options: Request | ApiOptions = {}) {
+   async getApi(options?: LocalApiOptions) {
       const fetcher = this.server.request as typeof fetch;
-      if (options instanceof Request) {
+      if (options && options instanceof Request) {
-         return new Api({ request: options, headers: options.headers, fetcher });
+         const api = new Api({ request: options, headers: options.headers, fetcher });
+         await api.verifyAuth();
+         return api;
       }
 
-      return new Api({ host: "http://localhost", ...options, fetcher });
+      return new Api({ host: "http://localhost", ...(options ?? {}), fetcher });
    }
 }
 

app/src/adapter/nextjs/nextjs.adapter.ts

@@ -1,49 +1,35 @@
-import type { IncomingMessage, ServerResponse } from "node:http";
-import { nodeRequestToRequest } from "adapter/utils";
 import type { App } from "bknd";
 import { type FrameworkBkndConfig, createFrameworkApp } from "bknd/adapter";
-import { Api } from "bknd/client";
 
 export type NextjsBkndConfig = FrameworkBkndConfig & {
-   cleanSearch?: string[];
+   cleanRequest?: { searchParams?: string[] };
 };
 
-type GetServerSidePropsContext = {
+let app: App;
-   req: IncomingMessage;
+let building: boolean = false;
-   res: ServerResponse;
-   params?: Params;
-   query: any;
-   preview?: boolean;
-   previewData?: any;
-   draftMode?: boolean;
-   resolvedUrl: string;
-   locale?: string;
-   locales?: string[];
-   defaultLocale?: string;
-};
 
-export function createApi({ req }: GetServerSidePropsContext) {
+export async function getApp(config: NextjsBkndConfig) {
-   const request = nodeRequestToRequest(req);
+   if (building) {
-   return new Api({
+      while (building) {
-      host: new URL(request.url).origin,
+         await new Promise((resolve) => setTimeout(resolve, 5));
-      headers: request.headers
+      }
-   });
+      if (app) return app;
+   }
+
+   building = true;
+   if (!app) {
+      app = await createFrameworkApp(config);
+      await app.build();
+   }
+   building = false;
+   return app;
 }
 
-export function withApi<T>(handler: (ctx: GetServerSidePropsContext & { api: Api }) => T) {
+function getCleanRequest(req: Request, cleanRequest: NextjsBkndConfig["cleanRequest"]) {
-   return async (ctx: GetServerSidePropsContext & { api: Api }) => {
+   if (!cleanRequest) return req;
-      const api = createApi(ctx);
-      await api.verifyAuth();
-      return handler({ ...ctx, api });
-   };
-}
 
-function getCleanRequest(
-   req: Request,
-   { cleanSearch = ["route"] }: Pick<NextjsBkndConfig, "cleanSearch">
-) {
    const url = new URL(req.url);
-   cleanSearch?.forEach((k) => url.searchParams.delete(k));
+   cleanRequest?.searchParams?.forEach((k) => url.searchParams.delete(k));
 
    return new Request(url.toString(), {
       method: req.method,
@@ -52,13 +38,12 @@ function getCleanRequest(
    });
 }
 
-let app: App;
+export function serve({ cleanRequest, ...config }: NextjsBkndConfig = {}) {
-export function serve({ cleanSearch, ...config }: NextjsBkndConfig = {}) {
    return async (req: Request) => {
       if (!app) {
-         app = await createFrameworkApp(config);
+         app = await getApp(config);
       }
-      const request = getCleanRequest(req, { cleanSearch });
+      const request = getCleanRequest(req, cleanRequest);
-      return app.fetch(request, process.env);
+      return app.fetch(request);
    };
 }

app/src/adapter/remix/remix.adapter.ts

@@ -10,7 +10,10 @@ type RemixContext = {
 let app: App;
 let building: boolean = false;
 
-export async function getApp(config: RemixBkndConfig, args?: RemixContext) {
+export async function getApp<Args extends RemixContext = RemixContext>(
+   config: RemixBkndConfig<Args>,
+   args?: Args
+) {
    if (building) {
       while (building) {
          await new Promise((resolve) => setTimeout(resolve, 5));
@@ -31,7 +34,7 @@ export function serve<Args extends RemixContext = RemixContext>(
    config: RemixBkndConfig<Args> = {}
 ) {
    return async (args: Args) => {
-      app = await createFrameworkApp(config, args);
+      app = await getApp(config, args);
       return app.fetch(args.request);
    };
 }

app/src/index.ts

@@ -4,7 +4,8 @@ export {
    AppEvents,
    type AppConfig,
    type CreateAppConfig,
-   type AppPlugin
+   type AppPlugin,
+   type LocalApiOptions
 } from "./App";
 
 export {

examples/nextjs/src/bknd.ts

@@ -0,0 +1,68 @@
+import { App, type LocalApiOptions } from "bknd";
+import { type NextjsBkndConfig, getApp as getBkndApp } from "bknd/adapter/nextjs";
+import { boolean, em, entity, text } from "bknd/data";
+import { secureRandomString } from "bknd/utils";
+
+// the em() function makes it easy to create an initial schema
+const schema = em({
+   todos: entity("todos", {
+      title: text(),
+      done: boolean()
+   })
+});
+
+// register your schema to get automatic type completion
+type Database = (typeof schema)["DB"];
+declare module "bknd/core" {
+   interface DB extends Database {}
+}
+
+export const config = {
+   // we can use any libsql config, and if omitted, uses in-memory
+   connection: {
+      url: "http://localhost:8080"
+   },
+   // an initial config is only applied if the database is empty
+   initialConfig: {
+      data: schema.toJSON(),
+      // we're enabling auth ...
+      auth: {
+         enabled: true,
+         jwt: {
+            secret: secureRandomString(64)
+         }
+      }
+   },
+   options: {
+      // the seed option is only executed if the database was empty
+      seed: async (ctx) => {
+         await ctx.em.mutator("todos").insertMany([
+            { title: "Learn bknd", done: true },
+            { title: "Build something cool", done: false }
+         ]);
+      }
+   },
+   // here we can hook into the app lifecycle events ...
+   beforeBuild: async (app) => {
+      app.emgr.onEvent(
+         App.Events.AppFirstBoot,
+         async () => {
+            // ... to create an initial user
+            await app.module.auth.createUser({
+               email: "ds@bknd.io",
+               password: "12345678"
+            });
+         },
+         "sync"
+      );
+   }
+} as const satisfies NextjsBkndConfig;
+
+export async function getApp() {
+   return await getBkndApp(config);
+}
+
+export async function getApi(options?: LocalApiOptions) {
+   const app = await getApp();
+   return await app.getApi(options);
+}

examples/nextjs/src/pages/api/[...route].ts

@@ -1,7 +1,5 @@
-import { App } from "bknd";
+import { config as bkndConfig } from "@/bknd";
 import { serve } from "bknd/adapter/nextjs";
-import { boolean, em, entity, text } from "bknd/data";
-import { secureRandomString } from "bknd/utils";
 
 export const config = {
    runtime: "edge",
@@ -12,57 +10,9 @@ export const config = {
    unstable_allowDynamic: ["**/*.js"]
 };
 
-// the em() function makes it easy to create an initial schema
-const schema = em({
-   todos: entity("todos", {
-      title: text(),
-      done: boolean()
-   })
-});
-
-// register your schema to get automatic type completion
-type Database = (typeof schema)["DB"];
-declare module "bknd/core" {
-   interface DB extends Database {}
-}
-
 export default serve({
-   // we can use any libsql config, and if omitted, uses in-memory
+   cleanRequest: {
-   connection: {
+      searchParams: ["route"]
-      url: "http://localhost:8080"
    },
-   // an initial config is only applied if the database is empty
+   ...bkndConfig
-   initialConfig: {
-      data: schema.toJSON(),
-      // we're enabling auth ...
-      auth: {
-         enabled: true,
-         jwt: {
-            secret: secureRandomString(64)
-         }
-      }
-   },
-   options: {
-      // the seed option is only executed if the database was empty
-      seed: async (ctx) => {
-         await ctx.em.mutator("todos").insertMany([
-            { title: "Learn bknd", done: true },
-            { title: "Build something cool", done: false }
-         ]);
-      }
-   },
-   // here we can hook into the app lifecycle events ...
-   beforeBuild: async (app) => {
-      app.emgr.onEvent(
-         App.Events.AppFirstBoot,
-         async () => {
-            // ... to create an initial user
-            await app.module.auth.createUser({
-               email: "ds@bknd.io",
-               password: "12345678"
-            });
-         },
-         "sync"
-      );
-   }
 });

examples/nextjs/src/pages/index.tsx

@@ -1,12 +1,13 @@
-import { withApi } from "bknd/adapter/nextjs";
+import { getApi } from "@/bknd";
 import type { InferGetServerSidePropsType } from "next";
 
-export const getServerSideProps = withApi(async (context) => {
+export const getServerSideProps = async () => {
-   const { data = [] } = await context.api.data.readMany("todos");
+   const api = await getApi();
-   const user = context.api.getUser();
+   const { data = [] } = await api.data.readMany("todos");
+   const user = api.getUser();
 
    return { props: { data, user } };
-});
+};
 
 export default function Home({
    data,

examples/remix/app/bknd.ts

@@ -1,4 +1,4 @@
-import { App } from "bknd";
+import { App, type LocalApiOptions } from "bknd";
 import { registerLocalMediaAdapter } from "bknd/adapter/node";
 import { type RemixBkndConfig, getApp as getBkndApp } from "bknd/adapter/remix";
 import { boolean, em, entity, text } from "bknd/data";
@@ -76,17 +76,7 @@ export async function getApp(args?: { request: Request }) {
    return await getBkndApp(config, args);
 }
 
-/**
+export async function getApi(options?: LocalApiOptions) {
- * If args are given, it will use authentication details from the request
+   const app = await getApp();
- * @param args
+   return await app.getApi(options);
- */
-export async function getApi(args?: { request: Request }) {
-   const app = await getApp(args);
-   if (args) {
-      const api = app.getApi(args.request);
-      await api.verifyAuth();
-      return api;
-   }
-
-   return app.getApi();
 }