cooper-stack 0.5.2

package/src/queue.ts

@@ -0,0 +1,133 @@
+import { registry } from "./registry.js";
+
+export interface QueueConfig {
+  concurrency?: number;
+  retries?: number;
+  retryDelay?: "fixed" | "exponential";
+  timeout?: string;
+  deadLetter?: string;
+}
+
+export interface EnqueueOptions {
+  delay?: string;
+  priority?: "low" | "normal" | "high";
+  dedupeKey?: string;
+}
+
+export interface QueueClient<T> {
+  enqueue(data: T, opts?: EnqueueOptions): Promise<void>;
+  worker(name: string, config: { handler: (data: T) => Promise<void>; onFailure?: (data: T, error: Error) => Promise<void> }): any;
+  list(): Promise<{ id: string; data: T }[]>;
+  delete(id: string): Promise<void>;
+}
+
+/**
+ * Declare a job queue.
+ *
+ * ```ts
+ * export const EmailQueue = queue<{ to: string; subject: string; body: string }>(
+ *   "email-queue",
+ *   { concurrency: 10, retries: 3, retryDelay: "exponential", timeout: "30s", deadLetter: "email-dlq" }
+ * );
+ * ```
+ */
+export function queue<T = any>(name: string, config?: QueueConfig): QueueClient<T> {
+  // In-memory queue for local dev — backed by NATS JetStream
+  // In production: SQS, Cloud Tasks, Azure Storage Queues, or QStash
+  const jobs: { id: string; data: T; attempts: number; priority: string; scheduledAt: number }[] = [];
+  let processing = false;
+  let workerHandler: ((data: T) => Promise<void>) | null = null;
+  let failureHandler: ((data: T, error: Error) => Promise<void>) | null = null;
+  const concurrency = config?.concurrency ?? 1;
+  const maxRetries = config?.retries ?? 0;
+
+  const parseDuration = (dur: string): number => {
+    const m = dur.match(/^(\d+)(s|m|h|d)$/);
+    if (!m) return 0;
+    const mult: Record<string, number> = { s: 1000, m: 60000, h: 3600000, d: 86400000 };
+    return parseInt(m[1]) * (mult[m[2]] ?? 1000);
+  };
+
+  const processQueue = async () => {
+    if (processing || !workerHandler) return;
+    processing = true;
+
+    while (jobs.length > 0) {
+      const batch = jobs.splice(0, concurrency);
+      await Promise.allSettled(
+        batch.map(async (job) => {
+          if (job.scheduledAt > Date.now()) {
+            jobs.push(job); // not ready yet
+            return;
+          }
+          try {
+            await workerHandler!(job.data);
+          } catch (err) {
+            job.attempts++;
+            if (job.attempts <= maxRetries) {
+              const delay = config?.retryDelay === "exponential"
+                ? Math.pow(2, job.attempts - 1) * 1000
+                : 1000;
+              job.scheduledAt = Date.now() + delay;
+              jobs.push(job);
+            } else if (failureHandler) {
+              await failureHandler(job.data, err as Error);
+            }
+          }
+        })
+      );
+    }
+
+    processing = false;
+  };
+
+  const client: QueueClient<T> = {
+    async enqueue(data: T, opts?: EnqueueOptions) {
+      const id = crypto.randomUUID();
+      const delay = opts?.delay ? parseDuration(opts.delay) : 0;
+      jobs.push({
+        id,
+        data,
+        attempts: 0,
+        priority: opts?.priority ?? "normal",
+        scheduledAt: Date.now() + delay,
+      });
+
+      // Sort by priority
+      const priorityOrder: Record<string, number> = { high: 0, normal: 1, low: 2 };
+      jobs.sort((a, b) => (priorityOrder[a.priority] ?? 1) - (priorityOrder[b.priority] ?? 1));
+
+      // Trigger processing
+      setImmediate(() => processQueue());
+    },
+
+    worker(workerName: string, workerConfig) {
+      workerHandler = workerConfig.handler;
+      failureHandler = workerConfig.onFailure ?? null;
+
+      registry.registerQueue(name, {
+        name,
+        options: config ?? {},
+        worker: { name: workerName, handler: workerConfig.handler, onFailure: workerConfig.onFailure },
+      });
+
+      // Start processing any already-queued jobs
+      setImmediate(() => processQueue());
+
+      return { _cooper_type: "queue_worker", queue: name, name: workerName };
+    },
+
+    async list() {
+      return jobs.map((j) => ({ id: j.id, data: j.data }));
+    },
+
+    async delete(id: string) {
+      const idx = jobs.findIndex((j) => j.id === id);
+      if (idx >= 0) jobs.splice(idx, 1);
+    },
+  };
+
+  registry.registerQueue(name, { name, options: config ?? {} });
+
+  return client;
+}

package/src/registry.ts

@@ -0,0 +1,98 @@
+/**
+ * Internal registry — Cooper's Rust runtime communicates with JS workers
+ * by referencing registered handlers by name. This module tracks all
+ * declarations (routes, topics, crons, queues, etc.) so the bridge
+ * can look them up at runtime.
+ */
+
+export interface RegisteredRoute {
+  method: string;
+  path: string;
+  auth: boolean;
+  stream?: "sse" | "websocket";
+  validate?: any; // Zod schema
+  middleware: MiddlewareFn[];
+  handler: Function;
+  exportName: string;
+  sourceFile: string;
+}
+
+export interface RegisteredTopic {
+  name: string;
+  subscribers: Map<string, { handler: Function; options: any }>;
+}
+
+export interface RegisteredCron {
+  name: string;
+  schedule: string;
+  handler: Function;
+}
+
+export interface RegisteredQueue {
+  name: string;
+  options: any;
+  worker?: { name: string; handler: Function; onFailure?: Function };
+}
+
+export interface RegisteredDatabase {
+  name: string;
+  engine: string;
+  pool: any;
+}
+
+export interface RegisteredCache {
+  name: string;
+  options: any;
+}
+
+export interface RegisteredBucket {
+  name: string;
+  options: any;
+}
+
+export type MiddlewareFn = (req: any, next: (req: any) => Promise<any>) => Promise<any>;
+
+export type AuthHandlerFn = (token: string) => Promise<Record<string, any>>;
+
+class Registry {
+  routes: Map<string, RegisteredRoute> = new Map();
+  topics: Map<string, RegisteredTopic> = new Map();
+  crons: Map<string, RegisteredCron> = new Map();
+  queues: Map<string, RegisteredQueue> = new Map();
+  databases: Map<string, RegisteredDatabase> = new Map();
+  caches: Map<string, RegisteredCache> = new Map();
+  buckets: Map<string, RegisteredBucket> = new Map();
+  secrets: Map<string, () => Promise<string>> = new Map();
+  globalMiddleware: MiddlewareFn[] = [];
+  authHandler: AuthHandlerFn | null = null;
+
+  registerRoute(key: string, route: RegisteredRoute) {
+    this.routes.set(key, route);
+  }
+
+  registerTopic(name: string, topic: RegisteredTopic) {
+    this.topics.set(name, topic);
+  }
+
+  registerCron(name: string, cron: RegisteredCron) {
+    this.crons.set(name, cron);
+  }
+
+  registerQueue(name: string, queue: RegisteredQueue) {
+    this.queues.set(name, queue);
+  }
+
+  registerDatabase(name: string, db: RegisteredDatabase) {
+    this.databases.set(name, db);
+  }
+
+  setAuthHandler(handler: AuthHandlerFn) {
+    this.authHandler = handler;
+  }
+
+  addGlobalMiddleware(mw: MiddlewareFn) {
+    this.globalMiddleware.push(mw);
+  }
+}
+
+export const registry = new Registry();

package/src/secrets.ts

@@ -0,0 +1,40 @@
+/**
+ * Declare a secret — fetched at runtime, never in .env or source code.
+ *
+ * ```ts
+ * const stripeKey = secret("stripe-api-key");
+ * const client = new Stripe(await stripeKey());
+ * ```
+ */
+export function secret(name: string): () => Promise<string> {
+  let cached: string | null = null;
+
+  const resolve = async (): Promise<string> => {
+    if (cached !== null) return cached;
+
+    // 1. Check env var (set by `cooper secrets set`)
+    const envKey = `COOPER_SECRET_${name.toUpperCase().replace(/-/g, "_")}`;
+    const envVal = process.env[envKey];
+    if (envVal) {
+      cached = envVal;
+      return envVal;
+    }
+
+    // 2. Check .cooper/secrets/<env>/<name>
+    const fs = require("node:fs");
+    const path = require("node:path");
+    const env = process.env.COOPER_ENV ?? "local";
+    const secretPath = path.join(".cooper", "secrets", env, name);
+    if (fs.existsSync(secretPath)) {
+      const val: string = fs.readFileSync(secretPath, "utf-8").trim();
+      cached = val;
+      return val;
+    }
+
+    throw new Error(
+      `Secret "${name}" not found. Set it with: cooper secrets set ${name} --env ${env}`
+    );
+  };
+
+  return resolve;
+}

package/src/ssr.ts

@@ -0,0 +1,58 @@
+export interface PageConfig {
+  cache?: string;
+  auth?: boolean;
+}
+
+export interface PageContext {
+  params: Record<string, string>;
+  req?: any;
+  data?: any;
+}
+
+/**
+ * Define a server-rendered page.
+ *
+ * ```ts
+ * export default page(async ({ params }) => {
+ *   const { user } = await UsersService.getUser({ id: params.id });
+ *   return <div><h1>{user.name}</h1></div>;
+ * });
+ * ```
+ */
+export function page<T = any>(
+  render: (ctx: PageContext) => Promise<T>
+): { _cooper_type: "page"; render: typeof render } {
+  return { _cooper_type: "page", render };
+}
+
+/**
+ * Define a layout that wraps pages.
+ *
+ * ```ts
+ * export default layout(({ children }) => (
+ *   <div><Nav /><main>{children}</main><Footer /></div>
+ * ));
+ * ```
+ */
+export function layout<T = any>(
+  render: (props: { children: any }) => T
+): { _cooper_type: "layout"; render: typeof render } {
+  return { _cooper_type: "layout", render };
+}
+
+/**
+ * Define a page data loader — runs on the server, data passed to the page.
+ */
+export function pageLoader<T>(
+  loader: (ctx: PageContext) => Promise<T>
+): { _cooper_type: "loader"; loader: typeof loader } {
+  return { _cooper_type: "loader", loader };
+}
+
+/**
+ * Suspense boundary for streaming SSR.
+ */
+export function Suspense(_props: { fallback: any; children: any }) {
+  // Handled by the SSR renderer — this is a marker component
+  return null;
+}

package/src/storage.ts

@@ -0,0 +1,79 @@
+export interface BucketConfig {
+  public?: boolean;
+}
+
+export interface BucketClient {
+  upload(key: string, data: Buffer | Uint8Array, opts?: { contentType?: string }): Promise<void>;
+  download(key: string): Promise<Buffer>;
+  signedUrl(key: string, opts?: { ttl?: string }): Promise<string>;
+  delete(key: string): Promise<void>;
+  list(prefix?: string): Promise<{ key: string; size: number; lastModified: Date }[]>;
+}
+
+/**
+ * Declare an object storage bucket.
+ *
+ * ```ts
+ * export const avatars = bucket("avatars", { public: true });
+ * await avatars.upload("user-123/avatar.png", buffer, { contentType: "image/png" });
+ * ```
+ */
+export function bucket(name: string, config?: BucketConfig): BucketClient {
+  const fs = require("node:fs");
+  const path = require("node:path");
+
+  // Local storage directory — in production this maps to S3/GCS/Azure Blob
+  const localDir = path.join(
+    process.env.COOPER_STORAGE_DIR ?? ".cooper/storage",
+    name
+  );
+
+  return {
+    async upload(key: string, data: Buffer | Uint8Array, opts?: { contentType?: string }) {
+      const fullPath = path.join(localDir, key);
+      fs.mkdirSync(path.dirname(fullPath), { recursive: true });
+      fs.writeFileSync(fullPath, data);
+    },
+
+    async download(key: string): Promise<Buffer> {
+      const fullPath = path.join(localDir, key);
+      return fs.readFileSync(fullPath);
+    },
+
+    async signedUrl(key: string, opts?: { ttl?: string }): Promise<string> {
+      // In local dev, return a direct file path
+      // In production, generate a presigned S3/GCS URL
+      return `http://localhost:9400/storage/${name}/${key}`;
+    },
+
+    async delete(key: string): Promise<void> {
+      const fullPath = path.join(localDir, key);
+      if (fs.existsSync(fullPath)) fs.unlinkSync(fullPath);
+    },
+
+    async list(prefix?: string) {
+      const dir = prefix ? path.join(localDir, prefix) : localDir;
+      if (!fs.existsSync(dir)) return [];
+
+      const entries: { key: string; size: number; lastModified: Date }[] = [];
+      const walk = (d: string, rel: string) => {
+        for (const entry of fs.readdirSync(d, { withFileTypes: true })) {
+          const fullPath = path.join(d, entry.name);
+          const relPath = rel ? `${rel}/${entry.name}` : entry.name;
+          if (entry.isDirectory()) {
+            walk(fullPath, relPath);
+          } else {
+            const stat = fs.statSync(fullPath);
+            entries.push({
+              key: relPath,
+              size: stat.size,
+              lastModified: stat.mtime,
+            });
+          }
+        }
+      };
+      walk(dir, "");
+      return entries;
+    },
+  };
+}

package/tsconfig.json

@@ -0,0 +1,17 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+    "outDir": "dist",
+    "rootDir": "src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true
+  },
+  "include": ["src/**/*.ts"]
+}