bunderstack 0.16.0 → 0.17.0-beta.0

package/src/blueprint.ts

@@ -1,9 +1,10 @@
+import * as v from 'valibot'
 import { parse, stringify } from 'yaml'
-import { z } from 'zod'
 
 import type { BunderstackManifest } from './manifest'
 
 import { parseCron } from './jobs/cron'
+import { validateStandardSchema } from './standard-schema'
 
 export type MigrationMode = 'migrations' | 'push'
 
@@ -26,119 +27,97 @@ export type BunderstackBlueprint = {
   }
 }
 
-const nonEmpty = z.string().min(1)
-const relativePath = nonEmpty.refine(
-  (value) =>
-    !value.startsWith('/') &&
-    !value.includes('\\') &&
-    value.split('/').every((part) => part !== '' && part !== '..'),
-  { message: 'entry must be a relative path without traversal' },
+const nonEmpty = v.pipe(v.string(), v.minLength(1))
+const relativePath = v.pipe(
+  nonEmpty,
+  v.check(
+    (value) =>
+      !value.startsWith('/') &&
+      !value.includes('\\') &&
+      value.split('/').every((part) => part !== '' && part !== '..'),
+    'entry must be a relative path without traversal',
+  ),
 )
-const cronSchedule = nonEmpty.refine(
-  (value) => {
+const cronSchedule = v.pipe(
+  nonEmpty,
+  v.check((value) => {
     try {
       parseCron(value)
       return true
     } catch {
       return false
     }
-  },
-  { message: 'invalid cron schedule' },
+  }, 'invalid cron schedule'),
 )
 
-const blueprintSchema = z
-  .object({
-    version: z.literal(1),
-    generator: z
-      .object({ name: z.literal('bunderstack'), version: nonEmpty })
-      .strict(),
-    application: z
-      .object({
-        framework: z.literal('tanstack-start'),
-        scripts: z
-          .object({
-            build: z.literal('build'),
-            start: z.literal('start'),
-            worker: z.literal('worker').optional(),
-          })
-          .strict(),
-      })
-      .strict(),
-    bunderstack: z
-      .object({ entry: relativePath, manifestVersion: z.literal(3) })
-      .strict(),
-    resources: z
-      .object({
-        database: z
-          .object({
-            dialect: z.enum(['sqlite', 'pg']),
-            migrationsDirectory: relativePath,
-            migrationMode: z.enum(['migrations', 'push']),
-            tables: z.array(
-              z
-                .object({
-                  exportName: nonEmpty,
-                  physicalName: nonEmpty,
-                  system: z.boolean(),
-                })
-                .strict(),
-            ),
-          })
-          .strict(),
-        storage: z
-          .object({
-            defaultBucket: nonEmpty,
-            buckets: z.array(
-              z
-                .object({
-                  name: nonEmpty,
-                  visibility: z.enum(['public', 'private']),
-                })
-                .strict(),
-            ),
-          })
-          .strict(),
-        realtime: z
-          .object({ required: z.literal(true) })
-          .strict()
-          .optional(),
-      })
-      .strict(),
-    environment: z.array(
-      z
-        .object({
-          key: nonEmpty,
-          required: z.boolean(),
-          scope: z.enum(['server', 'client']),
-        })
-        .strict(),
+const blueprintSchema = v.strictObject({
+  version: v.literal(1),
+  generator: v.strictObject({
+    name: v.literal('bunderstack'),
+    version: nonEmpty,
+  }),
+  application: v.strictObject({
+    framework: v.literal('tanstack-start'),
+    scripts: v.strictObject({
+      build: v.literal('build'),
+      start: v.literal('start'),
+      worker: v.optional(v.literal('worker')),
+    }),
+  }),
+  bunderstack: v.strictObject({
+    entry: relativePath,
+    manifestVersion: v.literal(3),
+  }),
+  resources: v.strictObject({
+    database: v.strictObject({
+      dialect: v.picklist(['sqlite', 'pg']),
+      migrationsDirectory: relativePath,
+      migrationMode: v.picklist(['migrations', 'push']),
+      tables: v.array(
+        v.strictObject({
+          exportName: nonEmpty,
+          physicalName: nonEmpty,
+          system: v.boolean(),
+        }),
+      ),
+    }),
+    storage: v.strictObject({
+      defaultBucket: nonEmpty,
+      buckets: v.array(
+        v.strictObject({
+          name: nonEmpty,
+          visibility: v.picklist(['public', 'private']),
+        }),
+      ),
+    }),
+    realtime: v.optional(v.strictObject({ required: v.literal(true) })),
+  }),
+  environment: v.array(
+    v.strictObject({
+      key: nonEmpty,
+      required: v.boolean(),
+      scope: v.picklist(['server', 'client']),
+    }),
+  ),
+  background: v.strictObject({
+    worker: v.strictObject({ required: v.boolean() }),
+    jobs: v.array(v.strictObject({ name: nonEmpty })),
+    cron: v.array(
+      v.strictObject({
+        name: nonEmpty,
+        schedule: cronSchedule,
+        timezone: v.literal('UTC'),
+      }),
     ),
-    background: z
-      .object({
-        worker: z.object({ required: z.boolean() }).strict(),
-        jobs: z.array(z.object({ name: nonEmpty }).strict()),
-        cron: z.array(
-          z
-            .object({
-              name: nonEmpty,
-              schedule: cronSchedule,
-              timezone: z.literal('UTC'),
-            })
-            .strict(),
-        ),
-        maintenance: z.array(
-          z
-            .object({
-              name: z.literal('storage-sweep'),
-              schedule: cronSchedule,
-              timezone: z.literal('UTC'),
-            })
-            .strict(),
-        ),
-      })
-      .strict(),
-  })
-  .strict()
+    maintenance: v.array(
+      v.strictObject({
+        name: v.literal('storage-sweep'),
+        schedule: cronSchedule,
+        timezone: v.literal('UTC'),
+      }),
+    ),
+  }),
+})
 
 function sortBy<T>(entries: readonly T[], key: (entry: T) => string): T[] {
   return [...entries].sort((left, right) => key(left).localeCompare(key(right)))
@@ -154,7 +133,11 @@ function rejectDuplicates(collection: string, values: readonly string[]): void {
 }
 
 export function parseBlueprint(value: unknown): BunderstackBlueprint {
-  const blueprint = blueprintSchema.parse(value) as BunderstackBlueprint
+  const blueprint = validateStandardSchema(
+    blueprintSchema,
+    value,
+    'blueprint',
+  ) as BunderstackBlueprint
   rejectDuplicates(
     'database physical table',
     blueprint.resources.database.tables.map((entry) => entry.physicalName),

package/src/config.ts

@@ -1,14 +1,16 @@
 // src/config.ts
 import { betterAuth } from 'better-auth'
-import { z } from 'zod'
+import * as v from 'valibot'
 
+import type { AnyRouter } from '@orpc/server'
 import type { AuthSessionResolver, TableAccessInput } from './access'
+import type { BunderstackApiBuilder } from './api/builder'
 import type { DatabaseAdapter } from './database/adapter'
 import type { EmailConfigInput } from './email'
 import type { IdempotencyConfig } from './idempotency'
 import type { RateLimitConfig } from './rate-limit'
 
-import { validateEnv, type BaseEnv, type EnvConfigInput } from './env'
+import { validateEnv, type BaseEnv, type EnvConfigInput, type ValidatedEnv } from './env'
 import {
   resolveBuckets,
   type ResolvedStorageBuckets,
@@ -23,34 +25,35 @@ export type BetterAuthConfig = Omit<
 // Only the union-shaped options need runtime validation: they are the ones a
 // JavaScript caller can plausibly get wrong in a way that fails confusingly
 // downstream. Everything else is either typed-only or read raw from `options`.
-const RuntimeOptionsSchema = z.object({
-  rateLimit: z
-    .union([
-      z.boolean(),
-      z.object({
-        windowMs: z.number().optional(),
-        max: z.number().optional(),
+const RuntimeOptionsSchema = v.object({
+  rateLimit: v.optional(
+    v.union([
+      v.boolean(),
+      v.object({
+        windowMs: v.optional(v.number()),
+        max: v.optional(v.number()),
       }),
-    ])
-    .optional(),
-  idempotency: z
-    .union([z.boolean(), z.object({ ttlMs: z.number().optional() })])
-    .optional(),
-  realtime: z
-    .union([
-      z.boolean(),
-      z.object({
-        keepaliveMs: z.number().optional(),
-        bufferSize: z.number().optional(),
-        redis: z
-          .union([
-            z.string(),
-            z.object({ url: z.string(), token: z.string().optional() }),
-          ])
-          .optional(),
+    ]),
+  ),
+  idempotency: v.optional(
+    v.union([v.boolean(), v.object({ ttlMs: v.optional(v.number()) })]),
+  ),
+  realtime: v.optional(
+    v.union([
+      v.boolean(),
+      v.object({
+        bufferSize: v.optional(v.number()),
+        resumeSeconds: v.optional(v.number()),
+        redis: v.optional(
+          v.union([
+            v.string(),
+            v.object({ url: v.string(), token: v.optional(v.string()) }),
+          ]),
+        ),
       }),
-    ])
-    .optional(),
+    ]),
+  ),
+  openapi: v.optional(v.boolean()),
 })
 
 export type BunderstackConfig<
@@ -62,6 +65,7 @@ export type BunderstackConfig<
     | StorageConfigInput
     | undefined,
   TEnv extends EnvConfigInput | undefined = EnvConfigInput | undefined,
+  TCustomApiRouter extends AnyRouter | undefined = AnyRouter | undefined,
 > = {
   schema: TSchema
   access?: TAccess
@@ -73,8 +77,8 @@ export type BunderstackConfig<
   }
   auth?: BetterAuthConfig
   /**
-   * Reuse an application-owned session reader for CRUD, realtime, storage,
-   * and tRPC while keeping Bunderstack's auth handler available.
+   * Reuse an application-owned session reader for the unified API while
+   * keeping Bunderstack's auth handler available.
    */
   authResolver?: AuthSessionResolver
   storage?: TStorage
@@ -88,18 +92,20 @@ export type BunderstackConfig<
   background?: { autoStart?: boolean }
   email?: EmailConfigInput
   /**
-   * Custom Hono routes, mounted at root ahead of bunderstack's own. Declared as
-   * a callback because routes in a separate file cannot import the app that is
-   * still being constructed — the same reason `trpc` takes a builder.
+   * Unified oRPC API builder callback.
    */
-  routes?: (ctx: never) => unknown
+  api?: (
+    builder: BunderstackApiBuilder<TSchema, ValidatedEnv<TEnv>>,
+  ) => TCustomApiRouter
   rateLimit?: boolean | RateLimitConfig
   idempotency?: boolean | IdempotencyConfig
+  /** Generate and serve `/api/openapi.json`. Disabled by default. */
+  openapi?: boolean
   realtime?:
     | boolean
     | {
-        keepaliveMs?: number
         bufferSize?: number
+        resumeSeconds?: number
         redis?: string | { url: string; token?: string }
       }
 }
@@ -116,14 +122,26 @@ export type ResolvedConfig = {
   realtime?:
     | boolean
     | {
-        keepaliveMs?: number
         bufferSize?: number
+        resumeSeconds?: number
         redis?: string | { url: string; token?: string }
       }
 }
 
-export function resolveConfig<TSchema extends Record<string, unknown>>(
-  options: BunderstackConfig<TSchema>,
+export function resolveConfig<
+  TSchema extends Record<string, unknown>,
+  TAccess extends Record<string, TableAccessInput> | undefined = undefined,
+  TStorage extends StorageConfigInput | undefined = undefined,
+  TEnv extends EnvConfigInput | undefined = undefined,
+  TCustomApiRouter extends AnyRouter | undefined = undefined,
+>(
+  options: BunderstackConfig<
+    TSchema,
+    TAccess,
+    TStorage,
+    TEnv,
+    TCustomApiRouter
+  >,
   env?: BaseEnv,
   // Platform-injected overrides (Bunderhost & co.) beat code-level config so
   // apps with hardcoded local urls deploy unchanged.
@@ -132,7 +150,7 @@ export function resolveConfig<TSchema extends Record<string, unknown>>(
     string | undefined
   >,
 ): ResolvedConfig {
-  const parsed = RuntimeOptionsSchema.parse(options)
+  const parsed = v.parse(RuntimeOptionsSchema, options)
   // Self-validate when the caller didn't pass a pre-validated env, so
   // resolveConfig stays usable standalone.
   const resolvedEnv =