@alfredmouelle/create-stack 0.1.1 → 0.2.0

package/_stack/packages/jobs/src/core/port.ts

@@ -0,0 +1,37 @@
+/** Event through the jobs system. `name` routes to subscribed jobs; `data` is the serializable payload. */
+export interface JobEvent<T = unknown> {
+  name: string
+  data: T
+}
+
+/** Background work unit. Subscribes to one `event` name; `handler` runs on a matching event. */
+export interface JobDefinition<T = unknown> {
+  id: string
+  event: string
+  handler: (event: JobEvent<T>) => Promise<void> | void
+}
+
+/**
+ * The port the app depends on. Swap provider = swap adapter; this never changes.
+ *
+ * Minimal and event-driven. Rich provider features (steps, concurrency, cron,
+ * fan-out) are NOT modeled — use the underlying SDK directly. See the README.
+ */
+export interface JobsPort {
+  readonly name: string
+  /** Register a job. Returns the definition for collection/export. */
+  defineJob<T>(def: JobDefinition<T>): JobDefinition<T>
+  /** Emit an event, triggering every job subscribed to `event.name`. */
+  trigger<T>(event: JobEvent<T>): Promise<void>
+}
+
+/** Normalized adapter error so callers never catch provider types. */
+export class JobsError extends Error {
+  readonly adapter: string
+
+  constructor(message: string, options: { adapter: string; cause?: unknown }) {
+    super(message, { cause: options.cause })
+    this.name = 'JobsError'
+    this.adapter = options.adapter
+  }
+}

package/_stack/packages/jobs/src/index.ts

@@ -0,0 +1,23 @@
+export { type InngestConfig, InngestConfigSchema } from './adapters/inngest/config.js'
+export {
+  type InngestAdapterOptions,
+  type InngestFunction,
+  type InngestJobsAdapter,
+  type InngestLike,
+  type InngestServe,
+  inngestAdapter,
+  inngestFunctions,
+  inngestServeHandler,
+} from './adapters/inngest/index.js'
+export { type MemoryJobsAdapter, memoryAdapter } from './adapters/memory/index.js'
+export { type TriggerDevConfig, TriggerDevConfigSchema } from './adapters/trigger/config.js'
+export {
+  type TriggerDevAdapterOptions,
+  type TriggerDevJobsAdapter,
+  type TriggerDevLike,
+  type TriggerTask,
+  triggerDevAdapter,
+  triggerDevTasks,
+} from './adapters/trigger/index.js'
+export type { JobDefinition, JobEvent, JobsPort } from './core/port.js'
+export { JobsError } from './core/port.js'

package/_stack/packages/logger/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "@alfredmouelle/logger",
+  "version": "0.0.0",
+  "private": true,
+  "type": "module",
+  "exports": {
+    ".": "./src/index.ts"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {
+    "pino": "^10.3.1",
+    "valibot": "^1.4.1"
+  },
+  "devDependencies": {
+    "@types/node": "^22.10.2",
+    "tsdown": "^0.22.3",
+    "typescript": "^5.9.3",
+    "vitest": "^4.1.9"
+  }
+}

package/_stack/packages/logger/src/adapters/console/config.ts

@@ -0,0 +1,7 @@
+import * as v from 'valibot'
+
+export const ConsoleConfigSchema = v.object({
+  level: v.optional(v.picklist(['trace', 'debug', 'info', 'warn', 'error'] as const), 'info'),
+})
+
+export type ConsoleConfig = v.InferOutput<typeof ConsoleConfigSchema>

package/_stack/packages/logger/src/adapters/console/index.ts

@@ -0,0 +1,69 @@
+import * as v from 'valibot'
+import type { LogFields, Logger, LogLevel } from '../../core/port.js'
+import { ConsoleConfigSchema } from './config.js'
+
+export interface ConsoleAdapterOptions {
+  /** Min level to emit; lower-severity dropped. Defaults to `'info'`. */
+  level?: LogLevel
+  /** Fields pinned onto every line. */
+  bindings?: LogFields
+}
+
+const ORDER: Record<LogLevel, number> = {
+  trace: 10,
+  debug: 20,
+  info: 30,
+  warn: 40,
+  error: 50,
+}
+
+const SINK: Record<LogLevel, (...args: unknown[]) => void> = {
+  // biome-ignore lint/suspicious/noConsole: console adapter
+  trace: (...args) => console.debug(...args),
+  // biome-ignore lint/suspicious/noConsole: console adapter
+  debug: (...args) => console.debug(...args),
+  // biome-ignore lint/suspicious/noConsole: console adapter
+  info: (...args) => console.info(...args),
+  warn: (...args) => console.warn(...args),
+  error: (...args) => console.error(...args),
+}
+
+function format(level: LogLevel, msg: string, fields: LogFields): string {
+  const hasFields = Object.keys(fields).length > 0
+  return hasFields ? `[${level}] ${msg} ${JSON.stringify(fields)}` : `[${level}] ${msg}`
+}
+
+function build(min: number, bindings: LogFields): Logger {
+  const log = (level: LogLevel, msg: string, fields: LogFields = {}) => {
+    if (ORDER[level] < min) return
+    const merged = { ...bindings, ...fields }
+    SINK[level](format(level, msg, merged))
+  }
+
+  return {
+    name: 'console',
+    trace(msg, fields) {
+      log('trace', msg, fields)
+    },
+    debug(msg, fields) {
+      log('debug', msg, fields)
+    },
+    info(msg, fields) {
+      log('info', msg, fields)
+    },
+    warn(msg, fields) {
+      log('warn', msg, fields)
+    },
+    error(msg, fields) {
+      log('error', msg, fields)
+    },
+    child(childBindings) {
+      return build(min, { ...bindings, ...childBindings })
+    },
+  }
+}
+
+export function consoleAdapter(options: ConsoleAdapterOptions = {}): Logger {
+  const config = v.parse(ConsoleConfigSchema, { level: options.level })
+  return build(ORDER[config.level], options.bindings ?? {})
+}

package/_stack/packages/logger/src/adapters/pino/index.ts

@@ -0,0 +1,54 @@
+import pino from 'pino'
+import type { LogFields, Logger, LogLevel } from '../../core/port.js'
+
+/**
+ * Minimal structural view of a pino logger (eases testing).
+ * Level methods follow pino's `(mergingObject, message)` convention.
+ */
+export interface PinoLike {
+  trace(obj: LogFields, msg: string): void
+  debug(obj: LogFields, msg: string): void
+  info(obj: LogFields, msg: string): void
+  warn(obj: LogFields, msg: string): void
+  error(obj: LogFields, msg: string): void
+  child(bindings: LogFields): PinoLike
+}
+
+export interface PinoAdapterOptions {
+  /** Min level to emit; defaults to `'info'`. */
+  level?: LogLevel
+  /** Fields pinned onto every line. */
+  bindings?: LogFields
+  /** Inject a custom/mock pino; defaults to a real `pino()`. */
+  client?: PinoLike
+}
+
+function wrap(client: PinoLike): Logger {
+  return {
+    name: 'pino',
+    trace(msg, fields = {}) {
+      client.trace(fields, msg)
+    },
+    debug(msg, fields = {}) {
+      client.debug(fields, msg)
+    },
+    info(msg, fields = {}) {
+      client.info(fields, msg)
+    },
+    warn(msg, fields = {}) {
+      client.warn(fields, msg)
+    },
+    error(msg, fields = {}) {
+      client.error(fields, msg)
+    },
+    child(bindings) {
+      return wrap(client.child(bindings))
+    },
+  }
+}
+
+export function pinoAdapter(options: PinoAdapterOptions = {}): Logger {
+  const base = options.client ?? (pino({ level: options.level ?? 'info' }) as unknown as PinoLike)
+  const client = options.bindings ? base.child(options.bindings) : base
+  return wrap(client)
+}

package/_stack/packages/logger/src/core/port.ts

@@ -0,0 +1,21 @@
+/** Severity levels, from most to least verbose. */
+export type LogLevel = 'trace' | 'debug' | 'info' | 'warn' | 'error'
+
+/** Arbitrary structured context attached to a log line. */
+export type LogFields = Record<string, unknown>
+
+/**
+ * App-facing port; swap adapters at the composition root, never this interface.
+ * Each method takes a message + optional fields; `child` merges `bindings` into every line.
+ */
+export interface Logger {
+  /** Adapter name (`'pino'`, `'console'`, …). */
+  readonly name: string
+  trace(msg: string, fields?: LogFields): void
+  debug(msg: string, fields?: LogFields): void
+  info(msg: string, fields?: LogFields): void
+  warn(msg: string, fields?: LogFields): void
+  error(msg: string, fields?: LogFields): void
+  /** Derive a logger pinning `bindings` onto subsequent lines. */
+  child(bindings: LogFields): Logger
+}

package/_stack/packages/logger/src/index.ts

@@ -0,0 +1,12 @@
+export { type ConsoleConfig, ConsoleConfigSchema } from './adapters/console/config.js'
+
+export {
+  type ConsoleAdapterOptions,
+  consoleAdapter,
+} from './adapters/console/index.js'
+export {
+  type PinoAdapterOptions,
+  type PinoLike,
+  pinoAdapter,
+} from './adapters/pino/index.js'
+export type { LogFields, Logger, LogLevel } from './core/port.js'

package/_stack/packages/mailer/src/adapters/brevo/index.ts

@@ -28,7 +28,7 @@ interface BrevoSendResponse {
   messageIds?: string[]
 }
 
-/** Minimal structural view of the Brevo client we depend on (eases testing). */
+/** Structural view of the Brevo client (eases testing). */
 export interface BrevoClientLike {
   transactionalEmails: {
     sendTransacEmail(request: BrevoSendRequest): Promise<BrevoSendResponse>
@@ -37,7 +37,7 @@ export interface BrevoClientLike {
 
 export interface BrevoAdapterOptions {
   apiKey: string
-  /** Inject a custom/mock client. Defaults to a real `BrevoClient`. */
+  /** Inject custom/mock client. Defaults to real `BrevoClient`. */
   client?: BrevoClientLike
 }
 
@@ -50,7 +50,7 @@ function toBase64(content: Uint8Array | string): string {
 }
 
 export function brevoAdapter(options: BrevoAdapterOptions): MailerAdapter {
-  // Validate config early so a missing key fails at construction, not at send().
+  // Validate early: missing key fails at construction, not send().
   const config = v.parse(BrevoConfigSchema, { apiKey: options.apiKey })
   const client: BrevoClientLike =
     options.client ?? (new BrevoClient({ apiKey: config.apiKey }) as unknown as BrevoClientLike)

package/_stack/packages/mailer/src/adapters/resend/index.ts

@@ -4,7 +4,7 @@ import { formatAddress } from '../../core/address.js'
 import { type MailerAdapter, MailerError, type RenderedMessage } from '../../core/port.js'
 import { ResendConfigSchema } from './config.js'
 
-/** Minimal structural view of the Resend client we depend on (eases testing). */
+/** Structural view of the Resend client (eases testing). */
 export interface ResendClient {
   emails: {
     send(payload: ResendSendPayload): Promise<{
@@ -30,7 +30,7 @@ interface ResendSendPayload {
 
 export interface ResendAdapterOptions {
   apiKey: string
-  /** Inject a custom/mock client. Defaults to a real `Resend` instance. */
+  /** Inject custom/mock client. Defaults to real `Resend`. */
   client?: ResendClient
 }
 
@@ -39,7 +39,7 @@ function toAttachmentContent(content: Uint8Array | string): Buffer | string {
 }
 
 export function resendAdapter(options: ResendAdapterOptions): MailerAdapter {
-  // Validate config early so a missing key fails at construction, not at send().
+  // Validate early: missing key fails at construction, not send().
   const config = v.parse(ResendConfigSchema, { apiKey: options.apiKey })
   const client: ResendClient =
     options.client ?? (new Resend(config.apiKey) as unknown as ResendClient)

package/_stack/packages/mailer/src/adapters/ses/config.ts

@@ -1,12 +1,12 @@
 import * as v from 'valibot'
 
 export const SesConfigSchema = v.object({
-  /** AWS region. Falls back to the SDK's resolution (e.g. `AWS_REGION`). */
+  /** AWS region. Falls back to SDK resolution (e.g. `AWS_REGION`). */
   region: v.optional(v.string()),
-  /** Static credentials. Omit to let the SDK resolve them (env, profile, IAM). */
+  /** Static credentials. Omit to let the SDK resolve (env, profile, IAM). */
   accessKeyId: v.optional(v.string()),
   secretAccessKey: v.optional(v.string()),
-  /** SES configuration set to attach (event publishing, dedicated IPs, …). */
+  /** SES configuration set (event publishing, dedicated IPs, …). */
   configurationSetName: v.optional(v.string()),
 })
 

package/_stack/packages/mailer/src/adapters/ses/index.ts

@@ -5,7 +5,7 @@ import { formatAddress } from '../../core/address.js'
 import { type MailerAdapter, MailerError, type RenderedMessage } from '../../core/port.js'
 import { SesConfigSchema } from './config.js'
 
-/** Minimal structural view of the SESv2 client we depend on (eases testing). */
+/** Structural view of the SESv2 client (eases testing). */
 export interface SesClientLike {
   send(command: { input: SesSendEmailInput }): Promise<{ MessageId?: string }>
 }
@@ -26,12 +26,12 @@ interface SesSendEmailInput {
 }
 
 export interface SesAdapterOptions {
-  /** AWS region. Falls back to the SDK's resolution (e.g. `AWS_REGION`). */
+  /** AWS region. Falls back to SDK resolution (e.g. `AWS_REGION`). */
   region?: string
   accessKeyId?: string
   secretAccessKey?: string
   configurationSetName?: string
-  /** Inject a custom/mock client. Defaults to a real `SESv2Client`. */
+  /** Inject custom/mock client. Defaults to real `SESv2Client`. */
   client?: SesClientLike
 }
 
@@ -56,8 +56,7 @@ export function sesAdapter(options: SesAdapterOptions = {}): MailerAdapter {
   return {
     name: 'ses',
     async send(message: RenderedMessage) {
-      // SES's Simple content can't carry attachments — that needs a raw MIME
-      // message, which this adapter intentionally doesn't build. Fail loudly.
+      // SES Simple content can't carry attachments (needs raw MIME, not built here). Fail loudly.
       if (message.attachments?.length) {
         throw new MailerError('SES adapter does not support attachments (requires raw MIME)', {
           adapter: 'ses',

package/_stack/packages/storage/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "@alfredmouelle/storage",
+  "version": "0.0.0",
+  "private": true,
+  "type": "module",
+  "exports": {
+    ".": "./src/index.ts"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {
+    "@aws-sdk/client-s3": "^3.1073.0",
+    "@aws-sdk/s3-request-presigner": "^3.1073.0",
+    "@google-cloud/storage": "^7.21.0",
+    "valibot": "^1.4.1"
+  },
+  "devDependencies": {
+    "@types/node": "^22.10.2",
+    "tsdown": "^0.22.3",
+    "typescript": "^5.9.3",
+    "vitest": "^4.1.9"
+  }
+}

package/_stack/packages/storage/src/adapters/gcs/config.ts

@@ -0,0 +1,8 @@
+import * as v from 'valibot'
+
+export const GcsConfigSchema = v.object({
+  bucket: v.pipe(v.string(), v.minLength(1, 'GCS_BUCKET is required')),
+  projectId: v.optional(v.string()),
+})
+
+export type GcsConfig = v.InferOutput<typeof GcsConfigSchema>

package/_stack/packages/storage/src/adapters/gcs/index.ts

@@ -0,0 +1,111 @@
+import { Storage } from '@google-cloud/storage'
+import * as v from 'valibot'
+import {
+  type PutOptions,
+  type SignedUrlOptions,
+  StorageError,
+  type StoragePort,
+} from '../../core/port.js'
+import { GcsConfigSchema } from './config.js'
+
+/** Structural view of a GCS file handle (eases testing). */
+export interface GcsFileLike {
+  save(data: Buffer | string, options?: { contentType?: string }): Promise<void>
+  download(): Promise<[Buffer]>
+  delete(): Promise<unknown>
+  exists(): Promise<[boolean]>
+  getSignedUrl(options: {
+    version: 'v4'
+    action: 'read' | 'write'
+    expires: number
+    contentType?: string
+  }): Promise<[string]>
+}
+
+/** Structural view of a GCS bucket handle. */
+export interface GcsBucketLike {
+  file(key: string): GcsFileLike
+}
+
+/** Structural view of the GCS Storage client. */
+export interface GcsStorageLike {
+  bucket(name: string): GcsBucketLike
+}
+
+export interface GcsAdapterOptions {
+  bucket: string
+  projectId?: string
+  /** Inject custom/mock client. Defaults to real `Storage`. */
+  client?: GcsStorageLike
+}
+
+const DEFAULT_EXPIRES_IN = 900
+
+function isNotFound(error: unknown): boolean {
+  if (typeof error !== 'object' || error === null) return false
+  return (error as { code?: number }).code === 404
+}
+
+export function gcsAdapter(options: GcsAdapterOptions): StoragePort {
+  // Validate early: missing config fails at construction, not use.
+  const config = v.parse(GcsConfigSchema, {
+    bucket: options.bucket,
+    projectId: options.projectId,
+  })
+
+  const client: GcsStorageLike =
+    options.client ?? (new Storage({ projectId: config.projectId }) as unknown as GcsStorageLike)
+
+  const bucket = client.bucket(config.bucket)
+
+  return {
+    name: 'gcs',
+    async put(key: string, data: Uint8Array | string, putOptions?: PutOptions) {
+      const body = typeof data === 'string' ? data : Buffer.from(data)
+      try {
+        await bucket.file(key).save(body, { contentType: putOptions?.contentType })
+      } catch (cause) {
+        throw new StorageError('GCS put failed', { adapter: 'gcs', cause })
+      }
+    },
+    async get(key: string) {
+      try {
+        const [contents] = await bucket.file(key).download()
+        return new Uint8Array(contents)
+      } catch (cause) {
+        if (isNotFound(cause)) return null
+        throw new StorageError('GCS get failed', { adapter: 'gcs', cause })
+      }
+    },
+    async delete(key: string) {
+      try {
+        await bucket.file(key).delete()
+      } catch (cause) {
+        if (isNotFound(cause)) return
+        throw new StorageError('GCS delete failed', { adapter: 'gcs', cause })
+      }
+    },
+    async exists(key: string) {
+      try {
+        const [found] = await bucket.file(key).exists()
+        return found
+      } catch (cause) {
+        throw new StorageError('GCS exists failed', { adapter: 'gcs', cause })
+      }
+    },
+    async getSignedUrl(key: string, urlOptions: SignedUrlOptions) {
+      const expiresInSeconds = urlOptions.expiresInSeconds ?? DEFAULT_EXPIRES_IN
+      try {
+        const [url] = await bucket.file(key).getSignedUrl({
+          version: 'v4',
+          action: urlOptions.operation === 'put' ? 'write' : 'read',
+          expires: Date.now() + expiresInSeconds * 1000,
+          contentType: urlOptions.contentType,
+        })
+        return url
+      } catch (cause) {
+        throw new StorageError('GCS getSignedUrl failed', { adapter: 'gcs', cause })
+      }
+    },
+  }
+}

package/_stack/packages/storage/src/adapters/local/config.ts

@@ -0,0 +1,8 @@
+import * as v from 'valibot'
+
+export const LocalConfigSchema = v.object({
+  baseDir: v.pipe(v.string(), v.minLength(1, 'STORAGE_LOCAL_DIR is required')),
+  publicBaseUrl: v.optional(v.string()),
+})
+
+export type LocalConfig = v.InferOutput<typeof LocalConfigSchema>

package/_stack/packages/storage/src/adapters/local/index.ts

@@ -0,0 +1,78 @@
+import { mkdir, readFile, stat, unlink, writeFile } from 'node:fs/promises'
+import { dirname, join } from 'node:path'
+import * as v from 'valibot'
+import {
+  type PutOptions,
+  type SignedUrlOptions,
+  StorageError,
+  type StoragePort,
+} from '../../core/port.js'
+import { LocalConfigSchema } from './config.js'
+
+export interface LocalAdapterOptions {
+  /** Root directory for stored objects. */
+  baseDir: string
+  /**
+   * Base URL prefixed to keys by {@link StoragePort.getSignedUrl}. NOT signed —
+   * returns `${publicBaseUrl}/${key}`. Dev/tests only.
+   */
+  publicBaseUrl?: string
+}
+
+function isNotFound(error: unknown): boolean {
+  if (typeof error !== 'object' || error === null) return false
+  return (error as { code?: string }).code === 'ENOENT'
+}
+
+export function localAdapter(options: LocalAdapterOptions): StoragePort {
+  const config = v.parse(LocalConfigSchema, {
+    baseDir: options.baseDir,
+    publicBaseUrl: options.publicBaseUrl,
+  })
+
+  const resolve = (key: string): string => join(config.baseDir, key)
+
+  return {
+    name: 'local',
+    async put(key: string, data: Uint8Array | string, _options?: PutOptions) {
+      const path = resolve(key)
+      try {
+        await mkdir(dirname(path), { recursive: true })
+        await writeFile(path, typeof data === 'string' ? data : Buffer.from(data))
+      } catch (cause) {
+        throw new StorageError('Local put failed', { adapter: 'local', cause })
+      }
+    },
+    async get(key: string) {
+      try {
+        const buffer = await readFile(resolve(key))
+        return new Uint8Array(buffer)
+      } catch (cause) {
+        if (isNotFound(cause)) return null
+        throw new StorageError('Local get failed', { adapter: 'local', cause })
+      }
+    },
+    async delete(key: string) {
+      try {
+        await unlink(resolve(key))
+      } catch (cause) {
+        if (isNotFound(cause)) return
+        throw new StorageError('Local delete failed', { adapter: 'local', cause })
+      }
+    },
+    async exists(key: string) {
+      try {
+        await stat(resolve(key))
+        return true
+      } catch (cause) {
+        if (isNotFound(cause)) return false
+        throw new StorageError('Local exists failed', { adapter: 'local', cause })
+      }
+    },
+    async getSignedUrl(key: string, _options: SignedUrlOptions) {
+      // No real signing; dev/test only.
+      const base = config.publicBaseUrl ?? ''
+      return `${base}/${key}`
+    },
+  }
+}

package/_stack/packages/storage/src/adapters/r2/config.ts

@@ -0,0 +1,8 @@
+import * as v from 'valibot'
+
+export const R2ConfigSchema = v.object({
+  bucket: v.pipe(v.string(), v.minLength(1, 'R2_BUCKET is required')),
+  accountId: v.pipe(v.string(), v.minLength(1, 'R2_ACCOUNT_ID is required')),
+})
+
+export type R2Config = v.InferOutput<typeof R2ConfigSchema>

package/_stack/packages/storage/src/adapters/r2/index.ts

@@ -0,0 +1,39 @@
+import * as v from 'valibot'
+import type { StoragePort } from '../../core/port.js'
+import { type S3ClientLike, type S3Presigner, s3Adapter } from '../s3/index.js'
+import { R2ConfigSchema } from './config.js'
+
+/**
+ * R2 is S3-compatible: {@link s3Adapter} with R2's endpoint
+ * (`https://<accountId>.r2.cloudflarestorage.com`) and `auto` region. All behavior inherited.
+ */
+export interface R2AdapterOptions {
+  bucket: string
+  /** Cloudflare account id (forms the R2 endpoint). */
+  accountId: string
+  accessKeyId?: string
+  secretAccessKey?: string
+  /** Inject custom/mock client. Defaults to real `S3Client`. */
+  client?: S3ClientLike
+  /** Inject custom/mock presigner. */
+  presign?: S3Presigner
+}
+
+export function r2Adapter(options: R2AdapterOptions): StoragePort {
+  const config = v.parse(R2ConfigSchema, {
+    bucket: options.bucket,
+    accountId: options.accountId,
+  })
+
+  const s3 = s3Adapter({
+    bucket: config.bucket,
+    region: 'auto',
+    endpoint: `https://${config.accountId}.r2.cloudflarestorage.com`,
+    accessKeyId: options.accessKeyId,
+    secretAccessKey: options.secretAccessKey,
+    client: options.client,
+    presign: options.presign,
+  })
+
+  return { ...s3, name: 'r2' }
+}

package/_stack/packages/storage/src/adapters/s3/config.ts

@@ -0,0 +1,11 @@
+import * as v from 'valibot'
+
+export const S3ConfigSchema = v.object({
+  bucket: v.pipe(v.string(), v.minLength(1, 'S3_BUCKET is required')),
+  region: v.pipe(v.string(), v.minLength(1, 'S3_REGION is required')),
+  accessKeyId: v.optional(v.string()),
+  secretAccessKey: v.optional(v.string()),
+  endpoint: v.optional(v.string()),
+})
+
+export type S3Config = v.InferOutput<typeof S3ConfigSchema>