cooper-stack 0.1.0

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"]
+}