@gencow/core 0.1.0

package/src/server.ts

@@ -0,0 +1,11 @@
+/**
+ * Platform Core — Server Implementations
+ *
+ * Includes Node.js specific modules (e.g. fs, path, crypto) needed for the
+ * executing server. Excluded from client-side core (`index.ts`) so they aren't
+ * bundled into user functions which run in Firecracker.
+ */
+export { createDb } from "./db";
+export { createStorage, storageRoutes } from "./storage";
+export { createScheduler, getSchedulerInfo } from "./scheduler";
+export { authMiddleware, authRoutes, getUsers } from "./auth";

package/src/storage.ts

@@ -0,0 +1,149 @@
+import * as fs from "fs/promises";
+import * as path from "path";
+import * as crypto from "crypto";
+
+// ─── Types ──────────────────────────────────────────────
+
+interface StorageFile {
+    id: string;
+    name: string;
+    size: number;
+    type: string;
+    path: string;
+}
+
+export interface Storage {
+    /** Store a file and return a storageId — Convex의 ctx.storage.store() */
+    store(file: File | Blob, filename?: string): Promise<string>;
+    /** Store from raw buffer */
+    storeBuffer(buffer: Buffer, filename: string, type?: string): Promise<string>;
+    /** Get a serving URL for the file — Convex의 ctx.storage.getUrl() */
+    getUrl(storageId: string): string;
+    /** Get file metadata */
+    getMeta(storageId: string): Promise<StorageFile | null>;
+    /** Delete a stored file — Convex의 ctx.storage.delete() */
+    delete(storageId: string): Promise<void>;
+}
+
+// ─── Implementation ─────────────────────────────────────
+
+const metaStore = new Map<string, StorageFile>();
+
+/**
+ * Create a storage instance — Convex storage 패턴 재현
+ *
+ * @example
+ * const storage = createStorage('./uploads');
+ * const id = await storage.store(file);
+ * const url = storage.getUrl(id);
+ */
+export function createStorage(dir: string = "./uploads"): Storage {
+    // Ensure directory exists
+    fs.mkdir(dir, { recursive: true }).catch(() => { });
+
+    return {
+        async store(file: File | Blob, filename?: string): Promise<string> {
+            const id = crypto.randomUUID();
+            const name = filename || (file instanceof File ? file.name : `${id}.bin`);
+            const filePath = path.join(dir, id);
+
+            const arrayBuffer = await file.arrayBuffer();
+            await fs.writeFile(filePath, Buffer.from(arrayBuffer));
+
+            metaStore.set(id, {
+                id,
+                name,
+                size: file.size,
+                type: file.type || "application/octet-stream",
+                path: filePath,
+            });
+
+            return id;
+        },
+
+        async storeBuffer(
+            buffer: Buffer,
+            filename: string,
+            type: string = "application/octet-stream"
+        ): Promise<string> {
+            const id = crypto.randomUUID();
+            const filePath = path.join(dir, id);
+
+            await fs.writeFile(filePath, buffer);
+
+            metaStore.set(id, {
+                id,
+                name: filename,
+                size: buffer.length,
+                type,
+                path: filePath,
+            });
+
+            return id;
+        },
+
+        getUrl(storageId: string): string {
+            return `/api/storage/${storageId}`;
+        },
+
+        async getMeta(storageId: string): Promise<StorageFile | null> {
+            return metaStore.get(storageId) || null;
+        },
+
+        async delete(storageId: string): Promise<void> {
+            const meta = metaStore.get(storageId);
+            if (meta) {
+                await fs.unlink(meta.path).catch(() => { });
+                metaStore.delete(storageId);
+            }
+        },
+    };
+}
+
+/**
+ * Hono routes for serving stored files
+ */
+export function storageRoutes(
+    storage: ReturnType<typeof createStorage>,
+    rawSql?: (sql: string, params?: any[]) => Promise<any[]>,
+    storageDir?: string,
+) {
+    return async (c: any) => {
+        const id = c.req.param("id");
+        let meta = await storage.getMeta(id);
+
+        // Fallback: DB lookup when in-memory meta is missing (e.g. after server restart)
+        if (!meta && rawSql) {
+            try {
+                const rows = await rawSql(
+                    `SELECT storage_id, name, size, type FROM files WHERE storage_id = $1 LIMIT 1`,
+                    [id]
+                );
+                if (rows.length > 0) {
+                    const row = rows[0];
+                    const dir = storageDir || "./uploads";
+                    meta = {
+                        id: row.storage_id,
+                        name: row.name,
+                        size: Number(row.size),
+                        type: row.type || "application/octet-stream",
+                        path: path.join(dir, row.storage_id),
+                    };
+                }
+            } catch { /* fallthrough to 404 */ }
+        }
+
+        if (!meta) {
+            return c.json({ error: "Not found" }, 404);
+        }
+
+        const file = await fs.readFile(meta.path);
+        return new Response(file, {
+            headers: {
+                "Content-Type": meta.type,
+                "Content-Disposition": `attachment; filename="${encodeURIComponent(meta.name)}"; filename*=UTF-8''${encodeURIComponent(meta.name)}`,
+                "Content-Length": String(meta.size),
+            },
+        });
+    };
+}

package/src/v.ts

@@ -0,0 +1,158 @@
+/**
+ * packages/core/src/v.ts
+ *
+ * Convex-style schema validator for API arguments.
+ * Provides both runtime validation and TypeScript type inference.
+ */
+
+/**
+ * Validation-specific error — thrown by parseArgs on invalid input.
+ * Allows the server dispatcher to safely distinguish 400 from 500
+ * without fragile string-matching on the error message.
+ */
+export class GencowValidationError extends Error {
+    readonly statusCode = 400;
+    constructor(message: string) {
+        super(message);
+        this.name = "GencowValidationError";
+    }
+}
+
+export type Validator<T = any> = {
+    parse(val: any): T;
+    _type: T; // Ghost property for TypeScript inference
+};
+
+export type Infer<T> = T extends Validator<infer U> ? U : never;
+
+export const v = {
+    string(): Validator<string> {
+        return {
+            parse: (val) => {
+                if (typeof val !== "string") throw new Error(`Expected string, got ${typeof val}`);
+                return val;
+            },
+            _type: "" as string,
+        };
+    },
+    number(): Validator<number> {
+        return {
+            parse: (val) => {
+                // Accept numeric strings (e.g. from URL params / form data)
+                const n = typeof val === "string" ? Number(val) : val;
+                if (typeof n !== "number" || isNaN(n)) throw new Error(`Expected number, got ${typeof val}`);
+                return n;
+            },
+            _type: 0 as number,
+        };
+    },
+    boolean(): Validator<boolean> {
+        return {
+            parse: (val) => {
+                if (typeof val !== "boolean") throw new Error(`Expected boolean, got ${typeof val}`);
+                return val;
+            },
+            _type: false as boolean,
+        };
+    },
+    any(): Validator<any> {
+        return {
+            parse: (val) => val,
+            _type: null as any,
+        };
+    },
+    optional<T>(inner: Validator<T>): Validator<T | undefined> {
+        return {
+            parse: (val) => {
+                if (val === undefined || val === null) return undefined;
+                return inner.parse(val);
+            },
+            _type: undefined as T | undefined,
+        };
+    },
+    object<T extends Record<string, Validator>>(fields: T): Validator<{ [K in keyof T]: Infer<T[K]> }> {
+        return {
+            parse: (val) => {
+                if (typeof val !== "object" || val === null) throw new Error("Expected object");
+                const result: any = {};
+                for (const key in fields) {
+                    result[key] = fields[key].parse((val as any)[key]);
+                }
+                return result;
+            },
+            _type: {} as any,
+        };
+    },
+    array<T>(inner: Validator<T>): Validator<T[]> {
+        return {
+            parse: (val) => {
+                if (!Array.isArray(val)) throw new Error("Expected array");
+                return val.map((item) => inner.parse(item));
+            },
+            _type: [] as T[],
+        };
+    },
+};
+
+/**
+ * Infer TypeScript type from a validator schema or a shorthand record of validators.
+ * Correctly handles optional properties (Validator<T | undefined> → optional key).
+ */
+export type InferArgs<T> = T extends Validator<infer U>
+    ? U
+    : T extends Record<string, Validator>
+    ? {
+        [K in keyof T as T[K] extends Validator<infer U>
+        ? (undefined extends U ? never : K)
+        : K]: T[K] extends Validator<infer U> ? U : any;
+    } & {
+        [K in keyof T as T[K] extends Validator<infer U>
+        ? (undefined extends U ? K : never)
+        : never]?: T[K] extends Validator<infer U> ? U : any;
+    }
+    : T;
+
+/**
+ * Validates and parses arguments against a schema at runtime.
+ *
+ * Supports:
+ *   - Full validators: `v.object({ id: v.number() })`, `v.string()`, `v.any()`, etc.
+ *   - Shorthand record: `{ id: v.number(), title: v.string() }` (Convex style)
+ *
+ * Throws `GencowValidationError` (HTTP 400) on validation failure.
+ */
+export function parseArgs(schema: any, args: any): any {
+    if (!schema) return args;
+
+    // Direct Validator (has a .parse method)
+    if (typeof schema.parse === "function") {
+        try {
+            return schema.parse(args);
+        } catch (e: any) {
+            throw new GencowValidationError(e.message);
+        }
+    }
+
+    // Shorthand object — e.g. { id: v.number(), title: v.optional(v.string()) }
+    if (typeof schema === "object" && schema !== null) {
+        if (typeof args !== "object" || args === null) {
+            throw new GencowValidationError("Expected an object for arguments");
+        }
+        const result: any = {};
+        for (const key in schema) {
+            const validator = schema[key];
+            if (validator && typeof validator.parse === "function") {
+                try {
+                    result[key] = validator.parse(args[key]);
+                } catch (e: any) {
+                    throw new GencowValidationError(`Argument "${key}": ${e.message}`);
+                }
+            } else {
+                result[key] = args[key];
+            }
+        }
+        return result;
+    }
+
+    return args;
+}