@cfast/core 0.1.4 → 0.3.0

package/dist/chunk-N7V3D574.js

@@ -0,0 +1,44 @@
+// src/define-plugin.ts
+function definePlugin(config) {
+  if (config === void 0) {
+    return (innerConfig) => innerConfig;
+  }
+  return config;
+}
+function definePluginFor() {
+  return (config) => config;
+}
+
+// src/presets.ts
+function createDefaultPlugins(config) {
+  const authPlugin = definePlugin({
+    name: "auth",
+    async setup(ctx) {
+      const auth = config.initAuth(ctx.env);
+      const authCtx = await auth.createContext(ctx.request);
+      return {
+        user: authCtx.user,
+        grants: authCtx.grants,
+        instance: auth
+      };
+    }
+  });
+  const dbPlugin = definePlugin({
+    name: "db",
+    requires: [authPlugin],
+    setup(ctx) {
+      const client = config.createDb(
+        ctx.auth.grants,
+        ctx.auth.user ? { id: ctx.auth.user.id } : null
+      );
+      return { client };
+    }
+  });
+  return { authPlugin, dbPlugin };
+}
+
+export {
+  definePlugin,
+  definePluginFor,
+  createDefaultPlugins
+};

package/dist/index.d.ts

@@ -3,6 +3,7 @@ import { Permissions } from '@cfast/permissions';
 import { C as CreateAppConfig, A as App, a as CfastPlugin, P as PluginSetupContext, R as RequiresFromPlugins } from './types-CQyKq4D1.js';
 export { b as AppContext, c as PluginContext, d as PluginProvides, e as RouteArgs } from './types-CQyKq4D1.js';
 import { ComponentType, ReactNode } from 'react';
+export { DefaultAuthProvides, DefaultDbProvides, DefaultPluginsConfig, createDefaultPlugins } from './presets.js';
 
 /**
  * Creates a cfast application instance that wires env, permissions, and plugins into a typed per-request context.
@@ -88,25 +89,35 @@ declare function createApp<TSchema extends Schema, TPermissions extends Permissi
  *     return { client: createDb({}) };
  *   },
  * });
+ *
+ * // Env-typed plugin — pass the env type as the single explicit generic
+ * // to type ctx.env precisely (no casts needed):
+ * const storagePlugin = definePlugin<Cloudflare.Env>({
+ *   name: 'storage',
+ *   setup(ctx) {
+ *     ctx.env.BUCKET; // typed as R2Bucket, not unknown
+ *     return { upload: (file: File) => ctx.env.BUCKET.put(file.name, file) };
+ *   },
+ * });
  * ```
  */
-declare function definePlugin<TName extends string, TProvides, const TRequires extends readonly CfastPlugin<string, unknown, any, unknown, any>[] = [], TClient = unknown>(config: {
+declare function definePlugin<TEnv = Record<string, unknown>, TName extends string = string, TProvides = unknown, const TRequires extends readonly CfastPlugin<string, unknown, any, unknown, any>[] = [], TClient = unknown>(config: {
     name: TName;
     requires?: TRequires;
-    setup: (ctx: PluginSetupContext<RequiresFromPlugins<TRequires>>) => TProvides | Promise<TProvides>;
+    setup: (ctx: PluginSetupContext<RequiresFromPlugins<TRequires>, TEnv>) => TProvides | Promise<TProvides>;
     Provider?: ComponentType<{
         children: ReactNode;
     }>;
     client?: TClient;
-}): CfastPlugin<TName, Awaited<TProvides>, RequiresFromPlugins<TRequires>, TClient>;
-declare function definePlugin<TRequires>(): <TName extends string, TProvides, TClient = unknown>(config: {
+}): CfastPlugin<TName, Awaited<TProvides>, RequiresFromPlugins<TRequires>, TClient, TEnv>;
+declare function definePlugin<TRequires, TEnv = Record<string, unknown>>(): <TName extends string, TProvides, TClient = unknown>(config: {
     name: TName;
-    setup: (ctx: PluginSetupContext<TRequires>) => TProvides | Promise<TProvides>;
+    setup: (ctx: PluginSetupContext<TRequires, TEnv>) => TProvides | Promise<TProvides>;
     Provider?: ComponentType<{
         children: ReactNode;
     }>;
     client?: TClient;
-}) => CfastPlugin<TName, Awaited<TProvides>, TRequires, TClient>;
+}) => CfastPlugin<TName, Awaited<TProvides>, TRequires, TClient, TEnv>;
 /**
  * Returns an env-typed `definePlugin` factory.
  *

package/dist/index.js

@@ -1,3 +1,8 @@
+import {
+  createDefaultPlugins,
+  definePlugin,
+  definePluginFor
+} from "./chunk-N7V3D574.js";
 import {
   createCoreProvider
 } from "./chunk-DFUBJVKG.js";
@@ -106,21 +111,11 @@ function buildApp(envInstance, permissions, plugins) {
   };
   return app;
 }
-
-// src/define-plugin.ts
-function definePlugin(config) {
-  if (config === void 0) {
-    return (innerConfig) => innerConfig;
-  }
-  return config;
-}
-function definePluginFor() {
-  return (config) => config;
-}
 export {
   CfastConfigError,
   CfastPluginError,
   createApp,
+  createDefaultPlugins,
   definePlugin,
   definePluginFor
 };

package/dist/presets.d.ts

@@ -0,0 +1,64 @@
+import { a as CfastPlugin } from './types-CQyKq4D1.js';
+import { Grant } from '@cfast/permissions';
+import '@cfast/env';
+import 'react';
+
+type AuthInstanceLike = {
+    createContext: (request: Request) => Promise<{
+        user: {
+            id: string;
+            email: string;
+            name: string;
+            [key: string]: unknown;
+        } | null;
+        grants: Grant[];
+    }>;
+};
+type DbFactory = (grants: Grant[], user: {
+    id: string;
+} | null) => unknown;
+type DefaultPluginsConfig = {
+    initAuth: (env: Record<string, unknown>) => AuthInstanceLike;
+    createDb: DbFactory;
+};
+type DefaultAuthProvides = {
+    user: {
+        id: string;
+        email: string;
+        name: string;
+        [key: string]: unknown;
+    } | null;
+    grants: Grant[];
+    instance: AuthInstanceLike;
+};
+type DefaultDbProvides = {
+    client: unknown;
+};
+declare function createDefaultPlugins(config: DefaultPluginsConfig): {
+    authPlugin: CfastPlugin<"auth", {
+        user: {
+            [key: string]: unknown;
+            id: string;
+            email: string;
+            name: string;
+        } | null;
+        grants: Grant[];
+        instance: AuthInstanceLike;
+    }, unknown, unknown, Record<string, unknown>>;
+    dbPlugin: CfastPlugin<"db", {
+        client: unknown;
+    }, {
+        auth: {
+            user: {
+                [key: string]: unknown;
+                id: string;
+                email: string;
+                name: string;
+            } | null;
+            grants: Grant[];
+            instance: AuthInstanceLike;
+        };
+    }, unknown, Record<string, unknown>>;
+};
+
+export { type DefaultAuthProvides, type DefaultDbProvides, type DefaultPluginsConfig, createDefaultPlugins };

package/dist/presets.js

@@ -0,0 +1,6 @@
+import {
+  createDefaultPlugins
+} from "./chunk-N7V3D574.js";
+export {
+  createDefaultPlugins
+};

package/llms.txt

@@ -138,6 +138,50 @@ with it slot into existing `app.use()` calls without further changes. If you
 prefer to type a single plugin in-place without a factory, import the
 `PluginContext<Env, TRequires>` helper and annotate the parameter directly.
 
+### Presets (`@cfast/core/presets`)
+
+```typescript
+import { createDefaultPlugins } from "@cfast/core/presets";
+
+function createDefaultPlugins(config: {
+  initAuth: (env: Record<string, unknown>) => AuthInstanceLike;
+  createDb: (grants: Grant[], user: { id: string } | null) => Db;
+}): { authPlugin, dbPlugin }
+```
+
+Creates the standard auth + db plugin pair that every cfast app uses. Replaces ~50 lines of identical plugin definitions across `cfast.server.ts` in every demo app.
+
+The auth plugin calls `initAuth(ctx.env)` per-request and returns `{ user, grants, instance }` under `ctx.auth`. The db plugin depends on the auth plugin and calls `createDb(grants, user)` to return `{ client }` under `ctx.db`.
+
+```typescript
+import { createApp } from "@cfast/core";
+import { createDefaultPlugins } from "@cfast/core/presets";
+import { envSchema } from "./env";
+import { permissions } from "./permissions";
+import { initAuth } from "./auth.setup.server";
+import { appDb } from "./db/client";
+
+const { authPlugin, dbPlugin } = createDefaultPlugins({
+  initAuth: (env) => initAuth({
+    d1: env.DB as D1Database,
+    appUrl: env.APP_URL as string,
+  }),
+  createDb: (grants, user) => appDb(grants, user),
+});
+
+export const app = createApp({ env: envSchema, permissions })
+  .use(authPlugin)
+  .use(dbPlugin);
+// Add app-specific plugins after the defaults:
+//  .use(storagePlugin)
+//  .use(emailPlugin);
+```
+
+Also re-exported from `@cfast/core` main entry for convenience:
+```typescript
+import { createDefaultPlugins } from "@cfast/core";
+```
+
 ### Client (`@cfast/core/client`)
 
 ```typescript

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cfast/core",
-  "version": "0.1.4",
+  "version": "0.3.0",
   "description": "App composition layer with plugin system for @cfast/* packages",
   "keywords": [
     "cfast",
@@ -26,6 +26,10 @@
     "./client": {
       "import": "./dist/client/index.js",
       "types": "./dist/client/index.d.ts"
+    },
+    "./presets": {
+      "import": "./dist/presets.js",
+      "types": "./dist/presets.d.ts"
     }
   },
   "files": [
@@ -60,12 +64,12 @@
     "tsup": "^8",
     "typescript": "^5.7",
     "vitest": "^4.1.0",
-    "@cfast/permissions": "0.5.1",
-    "@cfast/env": "0.2.1"
+    "@cfast/env": "0.2.1",
+    "@cfast/permissions": "0.5.1"
   },
   "scripts": {
-    "build": "tsup src/index.ts src/client/index.ts --format esm --dts",
-    "dev": "tsup src/index.ts src/client/index.ts --format esm --dts --watch",
+    "build": "tsup src/index.ts src/client/index.ts src/presets.ts --format esm --dts",
+    "dev": "tsup src/index.ts src/client/index.ts src/presets.ts --format esm --dts --watch",
     "typecheck": "tsc --noEmit",
     "lint": "eslint src/",
     "test": "vitest run --passWithNoTests"