appflare 0.0.28 → 0.1.1

package/server/database/query-builder.ts

@@ -1,161 +0,0 @@
-import type { Collection, Document, Filter, FindOptions, Sort } from "mongodb";
-import { applyPopulate } from "./populate";
-import {
-	normalizeIdFilter,
-	stringifyIdField,
-	toMongoFilter,
-} from "../utils/id-utils";
-import type { MongoDbQuery, SchemaRefMap } from "../types/types";
-import { buildProjection, normalizeSort } from "./query-utils";
-
-export function createQueryBuilder<
-	TTableNames extends string,
-	TTableDocMap extends Record<TTableNames, any>,
-	TableName extends TTableNames,
->(params: {
-	table: TableName;
-	getCollection: (table: string) => Collection<Document>;
-	refs: SchemaRefMap;
-}): MongoDbQuery<TableName, TTableDocMap, TTableDocMap[TableName]> {
-	let filter: Filter<Document> | undefined;
-	let sort: Sort | undefined;
-	let limit: number | undefined;
-	let offset: number | undefined;
-	let selectedKeys: string[] | undefined;
-	let populateKeys: string[] = [];
-	let populateAggregates: Record<
-		string,
-		{
-			count?: boolean;
-			sum?: string[];
-			avg?: string[];
-		}
-	> = {};
-	let populateIncludeDocs: Record<string, boolean> = {};
-
-	const normalizeAggregate = (
-		value: unknown
-	): { count?: boolean; sum?: string[]; avg?: string[] } | undefined => {
-		if (!value || typeof value !== "object") return undefined;
-		const spec = value as Record<string, unknown>;
-		const out: { count?: boolean; sum?: string[]; avg?: string[] } = {};
-		if (spec.count) out.count = true;
-		if (Array.isArray(spec.sum)) out.sum = spec.sum.map((k) => String(k));
-		if (Array.isArray(spec.avg)) out.avg = spec.avg.map((k) => String(k));
-		return Object.keys(out).length ? out : undefined;
-	};
-
-	const addPopulateKey = (
-		key: string,
-		opts?: {
-			aggregate?: { count?: boolean; sum?: string[]; avg?: string[] };
-			includeDocs?: boolean;
-		}
-	) => {
-		const ks = String(key);
-		if (!populateKeys.includes(ks)) populateKeys.push(ks);
-		if (opts?.aggregate) populateAggregates[ks] = opts.aggregate;
-		if (opts?.includeDocs !== undefined)
-			populateIncludeDocs[ks] = opts.includeDocs;
-	};
-
-	const api: MongoDbQuery<any, any, any> = {
-		where(next) {
-			const nextFilter = normalizeIdFilter(
-				toMongoFilter(next as unknown as Filter<Document>)
-			);
-			if (!filter) {
-				filter = nextFilter;
-			} else {
-				filter = { $and: [filter as any, nextFilter as any] } as any;
-			}
-			return api;
-		},
-		sort(next) {
-			sort = normalizeSort(next as any);
-			return api;
-		},
-		limit(n) {
-			limit = n;
-			return api;
-		},
-		offset(n) {
-			offset = n;
-			return api;
-		},
-		select(...args) {
-			const keys = Array.isArray(args[0])
-				? (args[0] as any[])
-				: (args as any[]);
-			selectedKeys = keys.map(String);
-			return api;
-		},
-		populate(arg: any) {
-			if (Array.isArray(arg)) {
-				for (const k of arg) addPopulateKey(k as any);
-				return api;
-			}
-
-			if (arg && typeof arg === "object") {
-				for (const [key, value] of Object.entries(
-					arg as Record<string, unknown>
-				)) {
-					if (!value) continue;
-					const includeObj =
-						typeof value === "object" && !Array.isArray(value)
-							? (value as Record<string, unknown>)
-							: undefined;
-					const aggregate = normalizeAggregate(includeObj?.aggregate);
-					const includeDocs = includeObj?.includeDocs;
-					addPopulateKey(key, { aggregate, includeDocs });
-				}
-				return api;
-			}
-
-			if (arg !== undefined) addPopulateKey(arg as any);
-			return api;
-		},
-		async find() {
-			const coll = params.getCollection(params.table as string);
-			const options: FindOptions = {};
-			if (selectedKeys) {
-				// Ensure referenced ids are available for populate even when the caller selected a subset.
-				const projectionKeys = Array.from(
-					new Set([...selectedKeys, ...populateKeys])
-				);
-				options.projection = buildProjection(projectionKeys);
-			}
-			const normalizedFilter = normalizeIdFilter(filter);
-			let cursor = coll.find(normalizedFilter ?? ({} as any), options);
-			if (sort) cursor = cursor.sort(sort);
-			if (offset !== undefined) cursor = cursor.skip(offset);
-			if (limit !== undefined) cursor = cursor.limit(limit);
-			const docs = (await cursor.toArray()) as Array<Record<string, unknown>>;
-			docs.forEach(stringifyIdField);
-
-			if (populateKeys.length > 0) {
-				await applyPopulate({
-					docs,
-					currentTable: params.table as string,
-					populateKeys,
-					aggregate: populateAggregates,
-					includeDocs: populateIncludeDocs,
-					selectedKeys,
-					refs: params.refs,
-					getCollection: params.getCollection,
-				});
-			}
-
-			return docs as any;
-		},
-		async findOne() {
-			if (limit === undefined || limit > 1) {
-				limit = 1;
-			}
-			const result = await api.find();
-			return (result[0] ?? null) as any;
-		},
-	};
-
-	return api as any;
-}

package/server/database/query-utils.ts

@@ -1,25 +0,0 @@
-import type { Sort } from "mongodb";
-import type { QuerySort } from "../types/types";
-
-export function buildProjection(keys: string[]): Record<string, 0 | 1> {
-	const projection: Record<string, 0 | 1> = {};
-	for (const k of keys) projection[k] = 1;
-
-	// Mongo includes _id by default; keep runtime aligned with schema-types `select()`.
-	if (!keys.includes("_id")) projection._id = 0;
-	if (!keys.includes("_creationTime")) projection._creationTime = 0;
-	return projection;
-}
-
-export function normalizeSort(sort: QuerySort<string>): Sort {
-	if (Array.isArray(sort)) {
-		return Object.fromEntries(
-			sort.map(([k, dir]) => [k, dir === "desc" ? -1 : 1])
-		);
-	}
-	const out: Record<string, 1 | -1> = {};
-	for (const [k, v] of Object.entries(sort ?? {})) {
-		out[k] = v === "desc" ? -1 : 1;
-	}
-	return out;
-}

package/server/db.ts

@@ -1,2 +0,0 @@
-export * from "./database/context";
-export * from "./types/types";

package/server/storage/auth.ts

@@ -1,16 +0,0 @@
-import type {
-	StorageAuthResult,
-	StorageBaseContext,
-	StorageRule,
-} from "./types";
-
-const allowAnonymous = <Principal>(): StorageAuthResult<Principal> => ({
-	allow: true,
-});
-
-export async function authorizeRequest<Env, Principal>(
-	ctx: StorageBaseContext<Env, Principal>,
-	rule: StorageRule<Env, Principal>
-): Promise<StorageAuthResult<Principal>> {
-	return rule.authorize ? rule.authorize(ctx) : allowAnonymous<Principal>();
-}

package/server/storage/bucket.ts

@@ -1,22 +0,0 @@
-import type { Context } from "hono";
-import type { R2Bucket } from "@cloudflare/workers-types";
-import type { StorageManagerOptions, StorageRule } from "./types";
-
-export function resolveBucket<Env, Principal>(
-	c: Context<Env>,
-	rule: StorageRule<Env, Principal>,
-	opts: StorageManagerOptions<Env, Principal>
-): Promise<R2Bucket> {
-	const resolver = rule.getBucket ?? opts.getBucket;
-	if (resolver) return Promise.resolve(resolver(c));
-	if (opts.bucketBinding) {
-		const bucket = (c.env as any)?.[opts.bucketBinding];
-		if (!bucket) {
-			throw new Error(
-				`Bucket binding ${opts.bucketBinding} was not found on the worker env.`
-			);
-		}
-		return Promise.resolve(bucket as R2Bucket);
-	}
-	throw new Error("Storage manager requires getBucket or bucketBinding.");
-}

package/server/storage/context.ts

@@ -1,34 +0,0 @@
-import type {
-	StorageBaseContext,
-	StorageKeyContext,
-	StorageRule,
-	StorageHttpMethod,
-} from "./types";
-import { deriveDefaultKey, normalizeKey } from "./utils";
-import type { Context } from "hono";
-
-export function buildBaseContext<Env, Principal>(
-	params: Record<string, string>,
-	method: StorageHttpMethod,
-	basePath: string,
-	c: Context<Env>
-): StorageBaseContext<Env, Principal> {
-	const wildcard = params["*"] ?? params["0"] ?? ""; // hono uses "0" for splat
-	const defaultKey = deriveDefaultKey(c.req.path, basePath);
-	return { c, params, wildcard, defaultKey, method };
-}
-
-export function buildKeyContext<Env, Principal>(
-	ctx: StorageBaseContext<Env, Principal>,
-	principal?: Principal
-): StorageKeyContext<Env, Principal> {
-	return { ...ctx, principal };
-}
-
-export function deriveStorageKey<Env, Principal>(
-	rule: StorageRule<Env, Principal>,
-	ctx: StorageKeyContext<Env, Principal>
-): string {
-	const key = (rule.deriveKey ?? ((keyCtx) => keyCtx.defaultKey))(ctx);
-	return normalizeKey(key);
-}

package/server/storage/index.ts

@@ -1,38 +0,0 @@
-import { Hono } from "hono";
-import { createRouteHandler } from "./route-handler";
-import { ensureMethods, joinPaths, normalizeBasePath } from "./utils";
-import type {
-	StorageHttpMethod,
-	StorageManagerOptions,
-	StorageRule,
-} from "./types";
-
-export function createR2StorageManager<Env = unknown, Principal = unknown>(
-	options: StorageManagerOptions<Env, Principal>
-): Hono<Env> {
-	const basePath = normalizeBasePath(options.basePath);
-	const app = new Hono<Env>();
-	const defaultCache =
-		options.defaultCacheControl ?? "private, max-age=0, must-revalidate";
-
-	for (const rule of options.rules) {
-		const routePath = joinPaths(basePath, rule.route ?? "");
-		const methods = ensureMethods(rule.methods);
-
-		for (const method of methods) {
-			app.on(
-				method,
-				routePath,
-				createRouteHandler(options, basePath, defaultCache, rule, method)
-			);
-		}
-	}
-
-	return app;
-}
-
-export type {
-	StorageManagerOptions,
-	StorageRule,
-	StorageHttpMethod,
-} from "./types";

package/server/storage/operations.ts

@@ -1,149 +0,0 @@
-import type {
-	StorageHttpMethod,
-	StorageKeyContext,
-	StorageRule,
-} from "./types";
-import type {
-	R2Bucket,
-	R2ObjectBody,
-	R2PutOptions,
-} from "@cloudflare/workers-types";
-
-async function respondWithObject(
-	object: R2ObjectBody,
-	cacheControl: string,
-	headOnly: boolean
-): Promise<Response> {
-	const headers = new Headers();
-	if (object.httpEtag) headers.set("etag", object.httpEtag);
-	if (object.size !== undefined)
-		headers.set("content-length", `${object.size}`);
-	if (object.httpMetadata?.contentType)
-		headers.set("content-type", object.httpMetadata.contentType);
-	headers.set("cache-control", cacheControl);
-	return headOnly
-		? new Response(null, { status: 200, headers })
-		: new Response(object.body as any, { status: 200, headers });
-}
-
-type ResolvedPayload = {
-	body: ArrayBuffer;
-	size: number;
-	contentType: string;
-};
-
-async function resolvePayload<Env, Principal>(
-	ctx: StorageKeyContext<Env, Principal>,
-	rule: StorageRule<Env, Principal>,
-	cacheControl: string
-): Promise<ResolvedPayload | Response> {
-	const headerContentType = ctx.c.req.header("content-type") ?? "";
-	const isMultipart = headerContentType
-		.toLowerCase()
-		.startsWith("multipart/form-data");
-
-	if (isMultipart) {
-		const form = await ctx.c.req.formData();
-		let file: File | null = null;
-		for (const value of form.values()) {
-			if (value instanceof File) {
-				file = value;
-				break;
-			}
-		}
-		if (!file) return ctx.c.json({ error: "No file found in form-data" }, 400);
-		const body = await file.arrayBuffer();
-		if (rule.maxSizeBytes && body.byteLength > rule.maxSizeBytes) {
-			return ctx.c.json({ error: "Payload too large" }, 413);
-		}
-		const contentType =
-			rule.contentType?.(ctx) ||
-			file.type ||
-			headerContentType ||
-			"application/octet-stream";
-		return { body, size: body.byteLength, contentType };
-	}
-
-	const body = await ctx.c.req.arrayBuffer();
-	if (rule.maxSizeBytes && body.byteLength > rule.maxSizeBytes) {
-		return ctx.c.json({ error: "Payload too large" }, 413);
-	}
-	const contentType =
-		rule.contentType?.(ctx) || headerContentType || "application/octet-stream";
-	return { body, size: body.byteLength, contentType };
-}
-
-async function handlePut<Env, Principal>(
-	bucket: R2Bucket,
-	key: string,
-	ctx: StorageKeyContext<Env, Principal>,
-	rule: StorageRule<Env, Principal>,
-	cacheControl: string
-): Promise<Response> {
-	const payload = await resolvePayload(ctx, rule, cacheControl);
-	if (payload instanceof Response) return payload;
-
-	const putOptions: R2PutOptions = {
-		httpMetadata: { contentType: payload.contentType, cacheControl },
-	};
-	await bucket.put(key, payload.body, putOptions);
-	return ctx.c.json(
-		{
-			key,
-			size: payload.size,
-			contentType: payload.contentType,
-			cacheControl,
-		},
-		201
-	);
-}
-
-async function handleGet(
-	bucket: R2Bucket,
-	key: string,
-	cacheControl: string,
-	headOnly: boolean
-): Promise<Response> {
-	const object = await bucket.get(key);
-	if (!object) return new Response(null, { status: 404 });
-	return respondWithObject(object, cacheControl, headOnly);
-}
-
-async function handleDelete<Env, Principal>(
-	bucket: R2Bucket,
-	key: string,
-	ctx: StorageKeyContext<Env, Principal>
-): Promise<Response> {
-	await bucket.delete(key);
-	return ctx.c.json({ key, deleted: true }, 200);
-}
-
-export type OperationParams<Env, Principal> = {
-	method: StorageHttpMethod;
-	bucket: R2Bucket;
-	key: string;
-	cacheControl: string;
-	ctx: StorageKeyContext<Env, Principal>;
-	rule: StorageRule<Env, Principal>;
-};
-
-export async function executeOperation<Env, Principal>(
-	params: OperationParams<Env, Principal>
-): Promise<Response> {
-	const { method, bucket, key, cacheControl, ctx, rule } = params;
-	switch (method) {
-		case "GET":
-			return handleGet(bucket, key, cacheControl, false);
-		case "HEAD":
-			return handleGet(bucket, key, cacheControl, true);
-		case "PUT":
-		case "POST":
-			return handlePut<Env, Principal>(bucket, key, ctx, rule, cacheControl);
-		case "DELETE":
-			return handleDelete(bucket, key, ctx);
-		case "OPTIONS":
-			return new Response(null, { status: 204 });
-		default:
-			return ctx.c.json({ error: "Method not allowed" }, 405);
-	}
-}

package/server/storage/route-handler.ts

@@ -1,60 +0,0 @@
-import { authorizeRequest } from "./auth";
-import { resolveBucket } from "./bucket";
-import { buildBaseContext, buildKeyContext, deriveStorageKey } from "./context";
-import { executeOperation } from "./operations";
-import type {
-	RouteHandler,
-	StorageHttpMethod,
-	StorageManagerOptions,
-	StorageRule,
-} from "./types";
-import { resolveCacheControl } from "./utils";
-import type { Context } from "hono";
-
-export function createRouteHandler<Env, Principal>(
-	options: StorageManagerOptions<Env, Principal>,
-	basePath: string,
-	defaultCache: string,
-	rule: StorageRule<Env, Principal>,
-	method: StorageHttpMethod
-): RouteHandler<Env> {
-	return async (c: Context<Env>) => {
-		const params = c.req.param();
-		const baseCtx = buildBaseContext<Env, Principal>(
-			params,
-			method,
-			basePath,
-			c
-		);
-
-		try {
-			if (method === "OPTIONS") {
-				return new Response(null, { status: 204 });
-			}
-			const bucket = await resolveBucket(c, rule, options);
-			const auth = await authorizeRequest(baseCtx, rule);
-			if (auth.allow === false) {
-				return c.json(
-					{ error: auth.message ?? "Unauthorized" },
-					(auth.status as any) ?? 403
-				);
-			}
-
-			const keyCtx = buildKeyContext(baseCtx, auth.principal);
-			const key = deriveStorageKey(rule, keyCtx);
-			const cacheControl = resolveCacheControl(rule, defaultCache);
-
-			return executeOperation({
-				method,
-				bucket,
-				key,
-				cacheControl,
-				ctx: keyCtx,
-				rule,
-			});
-		} catch (err) {
-			console.error("R2 storage manager error", err);
-			return c.json({ error: "Storage operation failed" }, 500);
-		}
-	};
-}

package/server/storage/types.ts

@@ -1,55 +0,0 @@
-import type { Context } from "hono";
-import type { R2Bucket } from "@cloudflare/workers-types";
-
-export type StorageHttpMethod =
-	| "GET"
-	| "HEAD"
-	| "PUT"
-	| "POST"
-	| "DELETE"
-	| "OPTIONS";
-export type Awaitable<T> = T | Promise<T>;
-
-export type StorageAuthResult<Principal = unknown> =
-	| { allow: true; principal?: Principal }
-	| { allow: false; status?: number; message?: string };
-
-export type StorageBaseContext<Env, Principal> = {
-	c: Context<Env>;
-	params: Record<string, string>;
-	wildcard: string;
-	defaultKey: string;
-	method: StorageHttpMethod;
-};
-
-export type StorageKeyContext<Env, Principal> = StorageBaseContext<
-	Env,
-	Principal
-> & {
-	principal?: Principal;
-};
-
-export type BucketResolver<Env> = (c: Context<Env>) => Awaitable<R2Bucket>;
-
-export type StorageRule<Env = unknown, Principal = unknown> = {
-	route?: string;
-	methods?: StorageHttpMethod[];
-	deriveKey?: (ctx: StorageKeyContext<Env, Principal>) => string;
-	authorize?: (
-		ctx: StorageBaseContext<Env, Principal>
-	) => Awaitable<StorageAuthResult<Principal>>;
-	getBucket?: BucketResolver<Env>;
-	maxSizeBytes?: number;
-	cacheControl?: string;
-	contentType?: (ctx: StorageKeyContext<Env, Principal>) => string | undefined;
-};
-
-export type StorageManagerOptions<Env = unknown, Principal = unknown> = {
-	basePath?: string;
-	rules: StorageRule<Env, Principal>[];
-	defaultCacheControl?: string;
-	bucketBinding?: string;
-	getBucket?: BucketResolver<Env>;
-};
-
-export type RouteHandler<Env> = (c: Context<Env>) => Promise<Response>;

package/server/storage/utils.ts

@@ -1,47 +0,0 @@
-import type { StorageHttpMethod, StorageRule } from "./types";
-
-export const DEFAULT_METHODS: StorageHttpMethod[] = [
-	"GET",
-	"HEAD",
-	"PUT",
-	"POST",
-	"DELETE",
-	"OPTIONS",
-];
-
-export function normalizeBasePath(basePath?: string): string {
-	if (!basePath) return "/storage";
-	if (!basePath.startsWith("/")) return `/${basePath}`;
-	return basePath;
-}
-
-export function joinPaths(base: string, route: string): string {
-	const trimmedBase = base.endsWith("/") ? base.slice(0, -1) : base;
-	const normalizedRoute = route.startsWith("/") ? route : `/${route}`;
-	return `${trimmedBase}${normalizedRoute}`;
-}
-
-export function deriveDefaultKey(path: string, basePath: string): string {
-	const normalizedBase = basePath.endsWith("/") ? basePath : `${basePath}/`;
-	const withoutBase = path.startsWith(normalizedBase)
-		? path.slice(normalizedBase.length)
-		: path.replace(/^\/+/, "");
-	return normalizeKey(withoutBase);
-}
-
-export function normalizeKey(key: string): string {
-	return key.replace(/^\/+/, "").replace(/\/+/g, "/");
-}
-
-export function ensureMethods(
-	methods?: StorageHttpMethod[]
-): StorageHttpMethod[] {
-	return methods && methods.length ? methods : DEFAULT_METHODS;
-}
-
-export function resolveCacheControl<Env, Principal>(
-	rule: StorageRule<Env, Principal>,
-	defaultCache: string
-): string {
-	return rule.cacheControl ?? defaultCache;
-}

package/server/storage.ts

@@ -1,6 +0,0 @@
-export { createR2StorageManager } from "./storage/index";
-export type {
-	StorageManagerOptions,
-	StorageRule,
-	StorageHttpMethod,
-} from "./storage/types";

package/server/types/schema-refs.ts

@@ -1,66 +0,0 @@
-import type { AnyZod, SchemaRefMap } from "./types";
-
-export function buildSchemaRefMap(
-	schema: Record<string, AnyZod>
-): SchemaRefMap {
-	const result: SchemaRefMap = new Map();
-	for (const [tableName, validator] of Object.entries(schema)) {
-		const tableRefs = new Map<string, string>();
-		const shape = getZodObjectShape(validator);
-		for (const [field, fieldSchema] of Object.entries(shape)) {
-			const ref = extractRefTableName(fieldSchema);
-			if (ref) tableRefs.set(field, ref);
-		}
-		result.set(tableName, tableRefs);
-	}
-	return result;
-}
-
-function extractRefTableName(schema: AnyZod): string | null {
-	if (!schema) return null;
-	const def = schema?._def;
-	const typeName: string | undefined = def?.typeName ?? def?.type;
-
-	if (typeName === "ZodOptional" || typeName === "optional") {
-		return extractRefTableName(
-			def?.innerType ?? def?.schema ?? schema?._def?.innerType
-		);
-	}
-	if (typeName === "ZodNullable" || typeName === "nullable") {
-		return extractRefTableName(def?.innerType ?? def?.schema);
-	}
-	if (typeName === "ZodDefault" || typeName === "default") {
-		return extractRefTableName(def?.innerType ?? def?.schema);
-	}
-	if (typeName === "ZodArray" || typeName === "array") {
-		return extractRefTableName(def?.element ?? def?.innerType ?? def?.type);
-	}
-	if (typeName === "ZodString" || typeName === "string") {
-		const description: string | undefined =
-			schema?.description ?? def?.description;
-		if (typeof description === "string" && description.startsWith("ref:")) {
-			return description.slice("ref:".length);
-		}
-		return null;
-	}
-
-	return null;
-}
-
-function getZodObjectShape(schema: AnyZod): Record<string, AnyZod> {
-	if (!schema || typeof schema !== "object") {
-		throw new Error(`Schema table is not an object`);
-	}
-
-	const def = schema?._def;
-	if (def?.typeName === "ZodObject" || def?.type === "object") {
-		const shape = def.shape;
-		if (typeof shape === "function") return shape();
-		if (shape && typeof shape === "object") return shape;
-	}
-
-	if (typeof schema.shape === "function") return schema.shape();
-	if (schema.shape && typeof schema.shape === "object") return schema.shape;
-
-	throw new Error(`Table schema is not a Zod object`);
-}