@geekmidas/constructs 7.0.1 → 10.0.0-alpha.0

package/src/endpoints/helpers.ts

@@ -1,98 +0,0 @@
-import path from 'node:path';
-import type { Service } from '@geekmidas/services';
-import fg from 'fast-glob';
-import type { HttpMethod } from '../types';
-import { Endpoint } from './Endpoint';
-
-// Re-export utility functions
-
-/**
- * Recursively finds the project root directory by looking for lock files.
- * Traverses up the directory tree until it finds a package manager lock file.
- *
- * @param cwd - The current working directory to start searching from
- * @returns Promise resolving to the absolute path of the project root
- *
- * @example
- * ```typescript
- * const projectRoot = await getProjectRoot(process.cwd());
- * console.log(`Project root: ${projectRoot}`);
- * // Output: Project root: /Users/user/my-project
- * ```
- */
-export async function getProjectRoot(cwd: string): Promise<string> {
-	if (cwd === '/') {
-		return cwd;
-	}
-
-	const stream = fg.stream(
-		['yarn.lock', 'pnpm-lock.yaml', 'package-lock.json', 'deno.lock'],
-		{ dot: true, cwd },
-	);
-
-	let isRoot = false;
-
-	for await (const _ of stream) {
-		isRoot = true;
-		break;
-	}
-
-	if (isRoot) {
-		return cwd;
-	}
-
-	return getProjectRoot(path.resolve(cwd, '..'));
-}
-
-/**
- * Discovers and imports all Endpoint instances from the specified route patterns.
- * Uses fast-glob to find files matching the patterns and extracts exported Endpoints.
- *
- * @template TServices - Array of service types used by the endpoints
- * @param routes - Array of glob patterns to match route files (e.g., ['src/routes/*.ts'])
- * @param cwd - The current working directory to resolve paths from
- * @returns Promise resolving to an array of Endpoint instances found in the matched files
- *
- * @example
- * ```typescript
- * // Find all endpoints in the routes directory
- * const endpoints = await getEndpointsFromRoutes(
- *   ['src/routes/**\/*.ts'],
- *   process.cwd()
- * );
- *
- * // Register endpoints with your server
- * for (const endpoint of endpoints) {
- *   server.register(endpoint);
- * }
- * ```
- *
- * @remarks
- * - Only exports that are valid Endpoint instances are included
- * - Files are imported dynamically, so they must be valid ES modules
- * - The function filters out non-Endpoint exports automatically
- */
-export async function getEndpointsFromRoutes<TServices extends Service[]>(
-	routes: string[],
-	cwd: string,
-): Promise<Endpoint<string, HttpMethod, any, any, TServices>[]> {
-	const stream = fg.stream(routes, { cwd });
-
-	const endpoints: Endpoint<string, HttpMethod, any, any, TServices>[] = [];
-
-	for await (const f of stream) {
-		// Resolve the absolute path for the route file
-		const routePath = path.resolve(cwd, f.toString());
-		// Dynamically import the route module
-		const route = await import(routePath);
-
-		// Filter exported values to find only Endpoint instances
-		const handlers = Object.values(route).filter((value) => {
-			return Endpoint.isEndpoint(value);
-		}) as unknown as Endpoint<string, HttpMethod, any, any, TServices>[];
-
-		endpoints.push(...handlers);
-	}
-
-	return endpoints;
-}

package/src/endpoints/index.ts

@@ -1,42 +0,0 @@
-import { EndpointFactory } from './EndpointFactory';
-
-export { publishConstructEvents } from '../publisher';
-export {
-	type Authorizer,
-	BUILT_IN_SECURITY_SCHEMES,
-	type BuiltInSecuritySchemeId,
-	createAuthorizer,
-	getSecurityScheme,
-	isBuiltInSecurityScheme,
-	type OAuthFlow,
-	type OAuthFlows,
-	type SecurityScheme,
-} from './Authorizer';
-export type { ActorExtractor, MappedAudit } from './audit';
-export {
-	Endpoint,
-	type EndpointContext,
-	type EndpointHandler,
-	type EndpointOutput,
-	type EndpointSchemas,
-	ResponseBuilder,
-} from './Endpoint';
-export { EndpointBuilder } from './EndpointBuilder';
-export { EndpointFactory } from './EndpointFactory';
-export {
-	createApiGatewayCookies,
-	createApiGatewayHeaders,
-	createHonoCookies,
-	createHonoHeaders,
-	createNoopCookies,
-	createNoopHeaders,
-} from './lazyAccessors';
-export {
-	RLS_BYPASS,
-	type RlsBypass,
-	type RlsConfig,
-	type RlsContext,
-	type RlsContextExtractor,
-} from './rls';
-
-export const e = new EndpointFactory();

package/src/endpoints/lazyAccessors.ts

@@ -1,241 +0,0 @@
-/**
- * Lazy header and cookie accessors for different adaptors.
- *
- * Instead of parsing all headers/cookies upfront, these accessors
- * use native adaptor methods for single lookups and only parse
- * everything when `header()` or `cookie()` is called without arguments.
- */
-import type { Context } from 'hono';
-import { getCookie } from 'hono/cookie';
-import type { CookieFn, HeaderFn } from './Endpoint';
-
-/**
- * Create a lazy header accessor for Hono.
- * Uses `c.req.header(name)` for single lookups (native, case-insensitive).
- * Only calls `c.req.header()` to get all headers when needed.
- */
-export function createHonoHeaders(c: Context): HeaderFn {
-	let allHeaders: Record<string, string> | null = null;
-
-	return ((key?: string) => {
-		if (key !== undefined) {
-			// Single header lookup - use native Hono method (case-insensitive)
-			return c.req.header(key);
-		}
-		// Get all headers - cache the result
-		if (!allHeaders) {
-			allHeaders = c.req.header();
-		}
-		return allHeaders;
-	}) as HeaderFn;
-}
-
-/**
- * Create a lazy cookie accessor for Hono.
- * Uses `getCookie(c, name)` for single lookups (native).
- * Only parses the cookie header when all cookies are requested.
- */
-export function createHonoCookies(c: Context): CookieFn {
-	let allCookies: Record<string, string> | null = null;
-
-	return ((name?: string) => {
-		if (name !== undefined) {
-			// Single cookie lookup - use native Hono method
-			return getCookie(c, name);
-		}
-		// Get all cookies - parse and cache
-		if (!allCookies) {
-			allCookies = {};
-			const cookieHeader = c.req.header('cookie');
-			if (cookieHeader) {
-				for (const part of cookieHeader.split(';')) {
-					const trimmed = part.trim();
-					const eqIndex = trimmed.indexOf('=');
-					if (eqIndex > 0) {
-						const key = trimmed.slice(0, eqIndex);
-						const value = trimmed.slice(eqIndex + 1);
-						allCookies[key] = value;
-					}
-				}
-			}
-		}
-		return allCookies;
-	}) as CookieFn;
-}
-
-/**
- * Create a lazy header accessor for API Gateway events.
- * Handles case-insensitive lookups.
- */
-export function createApiGatewayHeaders(
-	headers: Record<string, string | undefined> | null | undefined,
-): HeaderFn {
-	let normalizedHeaders: Record<string, string> | null = null;
-
-	const normalize = () => {
-		if (!normalizedHeaders) {
-			normalizedHeaders = {};
-			if (headers) {
-				for (const [k, v] of Object.entries(headers)) {
-					if (v !== undefined) {
-						normalizedHeaders[k.toLowerCase()] = v;
-					}
-				}
-			}
-		}
-		return normalizedHeaders;
-	};
-
-	return ((key?: string) => {
-		if (key !== undefined) {
-			// Try direct lookup first (common case: headers already lowercase)
-			if (headers) {
-				const direct = headers[key] ?? headers[key.toLowerCase()];
-				if (direct !== undefined) return direct;
-				// Fall back to normalized lookup
-				return normalize()[key.toLowerCase()];
-			}
-			return undefined;
-		}
-		return normalize();
-	}) as HeaderFn;
-}
-
-/**
- * Create a lazy cookie accessor for API Gateway events.
- * Decodes URL-encoded values to match browser behavior.
- */
-export function createApiGatewayCookies(
-	cookies: string[] | undefined,
-	cookieHeader: string | undefined,
-): CookieFn {
-	let parsed: Record<string, string> | null = null;
-
-	const parse = () => {
-		if (!parsed) {
-			parsed = {};
-			// API Gateway v2 provides cookies as array
-			if (cookies) {
-				for (const cookie of cookies) {
-					const eqIndex = cookie.indexOf('=');
-					if (eqIndex > 0) {
-						const key = cookie.slice(0, eqIndex);
-						const value = cookie.slice(eqIndex + 1);
-						parsed[key] = decodeURIComponent(value);
-					}
-				}
-			} else if (cookieHeader) {
-				// Fall back to parsing cookie header
-				for (const part of cookieHeader.split(';')) {
-					const trimmed = part.trim();
-					const eqIndex = trimmed.indexOf('=');
-					if (eqIndex > 0) {
-						const key = trimmed.slice(0, eqIndex);
-						const value = trimmed.slice(eqIndex + 1);
-						parsed[key] = decodeURIComponent(value);
-					}
-				}
-			}
-		}
-		return parsed;
-	};
-
-	return ((name?: string) => {
-		if (name !== undefined) {
-			return parse()[name];
-		}
-		return parse();
-	}) as CookieFn;
-}
-
-/**
- * Create a lazy header accessor for plain object headers (test adaptor, etc).
- * Headers are already available as an object, just provide lazy access.
- */
-export function createObjectHeaders(
-	headers: Record<string, string> | undefined,
-): HeaderFn {
-	let normalized: Record<string, string> | null = null;
-
-	return ((key?: string) => {
-		if (key !== undefined) {
-			// Try direct lookup first (common case)
-			if (headers) {
-				const direct = headers[key] ?? headers[key.toLowerCase()];
-				if (direct !== undefined) return direct;
-			}
-			// Fall back to normalized lookup for case-insensitivity
-			if (!normalized && headers) {
-				normalized = {};
-				for (const [k, v] of Object.entries(headers)) {
-					normalized[k.toLowerCase()] = v;
-				}
-			}
-			return normalized?.[key.toLowerCase()];
-		}
-		// Return all headers
-		if (!normalized && headers) {
-			normalized = {};
-			for (const [k, v] of Object.entries(headers)) {
-				normalized[k.toLowerCase()] = v;
-			}
-		}
-		return normalized ?? {};
-	}) as HeaderFn;
-}
-
-/**
- * Create a lazy cookie accessor from a cookie header string.
- * Decodes URL-encoded values to match browser behavior.
- */
-export function createCookieHeaderAccessor(
-	cookieHeader: string | undefined,
-): CookieFn {
-	let parsed: Record<string, string> | null = null;
-
-	const parse = () => {
-		if (!parsed) {
-			parsed = {};
-			if (cookieHeader) {
-				for (const part of cookieHeader.split(';')) {
-					const trimmed = part.trim();
-					const eqIndex = trimmed.indexOf('=');
-					if (eqIndex > 0) {
-						const key = trimmed.slice(0, eqIndex);
-						const value = trimmed.slice(eqIndex + 1);
-						// Decode URL-encoded values to match Endpoint.createCookies behavior
-						parsed[key] = decodeURIComponent(value);
-					}
-				}
-			}
-		}
-		return parsed;
-	};
-
-	return ((name?: string) => {
-		if (name !== undefined) {
-			return parse()[name];
-		}
-		return parse();
-	}) as CookieFn;
-}
-
-/**
- * Create a no-op header accessor (for minimal endpoints that don't use headers).
- */
-export function createNoopHeaders(): HeaderFn {
-	return ((key?: string) => {
-		if (key !== undefined) return undefined;
-		return {};
-	}) as HeaderFn;
-}
-
-/**
- * Create a no-op cookie accessor (for minimal endpoints that don't use cookies).
- */
-export function createNoopCookies(): CookieFn {
-	return ((name?: string) => {
-		if (name !== undefined) return undefined;
-		return {};
-	}) as CookieFn;
-}

package/src/endpoints/parseHonoQuery.ts

@@ -1,16 +0,0 @@
-import type { Context } from 'hono';
-import qs from 'qs';
-
-/**
- * Parse Hono query parameters using qs bracket notation
- * Supports nested objects, arrays, and deep nesting via standard bracket syntax
- */
-export function parseHonoQuery(c: Context): Record<string, any> {
-	const url = c.req.url;
-	const queryIndex = url.indexOf('?');
-	if (queryIndex === -1) {
-		return {};
-	}
-	const queryString = url.slice(queryIndex + 1);
-	return qs.parse(queryString) as Record<string, any>;
-}

package/src/endpoints/parseQueryParams.ts

@@ -1,32 +0,0 @@
-import qs from 'qs';
-
-/**
- * Parse query parameters from a flat object into a nested structure
- * Uses qs bracket notation for standard interoperability
- *
- * @example
- * parseQueryParams({ 'tags[]': ['a', 'b'], 'filter[name]': 'john' })
- * // Returns: { tags: ['a', 'b'], filter: { name: 'john' } }
- */
-export function parseQueryParams(
-	queryParams: Record<string, string | string[] | undefined> | null,
-): Record<string, any> {
-	if (!queryParams) {
-		return {};
-	}
-
-	// Reconstruct a query string from the flat object so qs can parse bracket notation
-	const parts: string[] = [];
-	for (const [key, value] of Object.entries(queryParams)) {
-		if (value === undefined) continue;
-		if (Array.isArray(value)) {
-			for (const v of value) {
-				parts.push(`${encodeURIComponent(key)}=${encodeURIComponent(v)}`);
-			}
-		} else {
-			parts.push(`${encodeURIComponent(key)}=${encodeURIComponent(value)}`);
-		}
-	}
-
-	return qs.parse(parts.join('&')) as Record<string, any>;
-}