@venturekit/runtime 0.0.0-dev.20260307234057

package/LICENSE

@@ -0,0 +1,191 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to the Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by the Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding any notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   Copyright 2025 VentureKit Contributors
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/dist/context.d.ts

@@ -0,0 +1,86 @@
+/**
+ * VentureKit Request Context
+ *
+ * Provides typed access to request metadata, user info, and tenant context.
+ * Extensible for future auth/tenancy modules.
+ */
+import type { APIGatewayProxyEventV2 } from 'aws-lambda';
+/**
+ * User information extracted from JWT claims
+ */
+export interface UserContext {
+    /** User ID (Cognito sub) */
+    id: string;
+    /** User email */
+    email?: string;
+    /** User's OAuth scopes */
+    scopes: string[];
+    /** Custom claims from JWT */
+    claims: Record<string, unknown>;
+}
+/**
+ * Tenant context for multi-tenant applications
+ * (Populated by @venturekit/tenancy when enabled)
+ */
+export interface TenantContext {
+    /** Tenant ID */
+    id: string;
+    /** Tenant slug/subdomain */
+    slug?: string;
+    /** Tenant-specific metadata */
+    metadata: Record<string, unknown>;
+}
+/**
+ * Request context passed to all handlers
+ */
+export interface RequestContext {
+    /** Unique request ID for tracing */
+    requestId: string;
+    /** Request timestamp */
+    timestamp: Date;
+    /** HTTP method */
+    method: string;
+    /** Request path */
+    path: string;
+    /** Source IP address */
+    sourceIp: string;
+    /** User agent */
+    userAgent: string;
+    /** User context (populated for authenticated requests) */
+    user: UserContext | null;
+    /** Tenant context (populated when tenancy is enabled) */
+    tenant: TenantContext | null;
+    /** Request locale (from Accept-Language or default) */
+    locale: string;
+    /** Raw AWS event (for advanced use cases) */
+    rawEvent: APIGatewayProxyEventV2;
+    /** Query params from the request */
+    queryParams?: Record<string, string | undefined>;
+    /**
+     * Database transaction (populated when handler has transactional: true)
+     * Use tx.query() to run all queries within the same transaction.
+     * The transaction is auto-committed on success, rolled back on error.
+     */
+    tx?: unknown;
+    /**
+     * Infrastructure intent outputs (populated after infra provisioning).
+     * Provides access to provisioned resource endpoints, ARNs, etc.
+     * Hydrated from the VENTURE_INTENT_OUTPUTS environment variable.
+     */
+    intentOutputs?: Record<string, unknown>;
+}
+/**
+ * Extract user context from JWT claims in API Gateway event
+ */
+export declare function extractUserContext(event: APIGatewayProxyEventV2): UserContext | null;
+/**
+ * Extract locale from Accept-Language header
+ */
+export declare function extractLocale(event: APIGatewayProxyEventV2, supportedLocales: string[], defaultLocale: string): string;
+/**
+ * Build request context from API Gateway event
+ */
+export declare function buildContext(event: APIGatewayProxyEventV2, options: {
+    supportedLocales: string[];
+    defaultLocale: string;
+}): RequestContext;

package/dist/context.js

@@ -0,0 +1,76 @@
+"use strict";
+/**
+ * VentureKit Request Context
+ *
+ * Provides typed access to request metadata, user info, and tenant context.
+ * Extensible for future auth/tenancy modules.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractUserContext = extractUserContext;
+exports.extractLocale = extractLocale;
+exports.buildContext = buildContext;
+/**
+ * Extract user context from JWT claims in API Gateway event
+ */
+function extractUserContext(event) {
+    const claims = event.requestContext?.authorizer?.jwt?.claims;
+    if (!claims) {
+        return null;
+    }
+    const sub = claims.sub;
+    if (!sub) {
+        return null;
+    }
+    // Extract scopes from 'scope' claim (space-separated)
+    const scopeString = claims.scope;
+    const scopes = scopeString ? scopeString.split(' ') : [];
+    return {
+        id: sub,
+        email: claims.email,
+        scopes,
+        claims: claims,
+    };
+}
+/**
+ * Extract locale from Accept-Language header
+ */
+function extractLocale(event, supportedLocales, defaultLocale) {
+    const acceptLanguage = event.headers?.['accept-language'] || '';
+    // Parse Accept-Language header (simplified)
+    const requested = acceptLanguage.split(',')[0]?.split('-')[0]?.toLowerCase();
+    if (requested && supportedLocales.includes(requested)) {
+        return requested;
+    }
+    return defaultLocale;
+}
+/**
+ * Build request context from API Gateway event
+ */
+function buildContext(event, options) {
+    // Hydrate intent outputs from env var (set by infra layer after provisioning)
+    let intentOutputs;
+    try {
+        const raw = process.env.VENTURE_INTENT_OUTPUTS;
+        if (raw) {
+            intentOutputs = JSON.parse(raw);
+        }
+    }
+    catch {
+        // Ignore parse errors — intentOutputs stays undefined
+    }
+    return {
+        requestId: event.requestContext?.requestId || crypto.randomUUID(),
+        timestamp: new Date(),
+        method: event.requestContext?.http?.method || 'UNKNOWN',
+        path: event.requestContext?.http?.path || '/',
+        sourceIp: event.requestContext?.http?.sourceIp || 'unknown',
+        userAgent: event.headers?.['user-agent'] || 'unknown',
+        user: extractUserContext(event),
+        tenant: null, // Populated by @venturekit/tenancy
+        locale: extractLocale(event, options.supportedLocales, options.defaultLocale),
+        rawEvent: event,
+        queryParams: event.queryStringParameters,
+        intentOutputs,
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"context.js","sourceRoot":"","sources":["../src/context.ts"],"names":[],"mappings":";AAAA;;;;;GAKG;;AAsFH,gDAsBC;AAKD,sCAeC;AAKD,oCAgCC;AAlFD;;GAEG;AACH,SAAgB,kBAAkB,CAAC,KAA6B;IAC9D,MAAM,MAAM,GAAI,KAAK,CAAC,cAAsB,EAAE,UAAU,EAAE,GAAG,EAAE,MAAM,CAAC;IAEtE,IAAI,CAAC,MAAM,EAAE,CAAC;QACZ,OAAO,IAAI,CAAC;IACd,CAAC;IAED,MAAM,GAAG,GAAG,MAAM,CAAC,GAAyB,CAAC;IAC7C,IAAI,CAAC,GAAG,EAAE,CAAC;QACT,OAAO,IAAI,CAAC;IACd,CAAC;IAED,sDAAsD;IACtD,MAAM,WAAW,GAAG,MAAM,CAAC,KAA2B,CAAC;IACvD,MAAM,MAAM,GAAG,WAAW,CAAC,CAAC,CAAC,WAAW,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;IAEzD,OAAO;QACL,EAAE,EAAE,GAAG;QACP,KAAK,EAAE,MAAM,CAAC,KAA2B;QACzC,MAAM;QACN,MAAM,EAAE,MAAiC;KAC1C,CAAC;AACJ,CAAC;AAED;;GAEG;AACH,SAAgB,aAAa,CAC3B,KAA6B,EAC7B,gBAA0B,EAC1B,aAAqB;IAErB,MAAM,cAAc,GAAG,KAAK,CAAC,OAAO,EAAE,CAAC,iBAAiB,CAAC,IAAI,EAAE,CAAC;IAEhE,4CAA4C;IAC5C,MAAM,SAAS,GAAG,cAAc,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,EAAE,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,EAAE,WAAW,EAAE,CAAC;IAE7E,IAAI,SAAS,IAAI,gBAAgB,CAAC,QAAQ,CAAC,SAAS,CAAC,EAAE,CAAC;QACtD,OAAO,SAAS,CAAC;IACnB,CAAC;IAED,OAAO,aAAa,CAAC;AACvB,CAAC;AAED;;GAEG;AACH,SAAgB,YAAY,CAC1B,KAA6B,EAC7B,OAGC;IAED,8EAA8E;IAC9E,IAAI,aAAkD,CAAC;IACvD,IAAI,CAAC;QACH,MAAM,GAAG,GAAG,OAAO,CAAC,GAAG,CAAC,sBAAsB,CAAC;QAC/C,IAAI,GAAG,EAAE,CAAC;YACR,aAAa,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;QAClC,CAAC;IACH,CAAC;IAAC,MAAM,CAAC;QACP,sDAAsD;IACxD,CAAC;IAED,OAAO;QACL,SAAS,EAAE,KAAK,CAAC,cAAc,EAAE,SAAS,IAAI,MAAM,CAAC,UAAU,EAAE;QACjE,SAAS,EAAE,IAAI,IAAI,EAAE;QACrB,MAAM,EAAE,KAAK,CAAC,cAAc,EAAE,IAAI,EAAE,MAAM,IAAI,SAAS;QACvD,IAAI,EAAE,KAAK,CAAC,cAAc,EAAE,IAAI,EAAE,IAAI,IAAI,GAAG;QAC7C,QAAQ,EAAE,KAAK,CAAC,cAAc,EAAE,IAAI,EAAE,QAAQ,IAAI,SAAS;QAC3D,SAAS,EAAE,KAAK,CAAC,OAAO,EAAE,CAAC,YAAY,CAAC,IAAI,SAAS;QACrD,IAAI,EAAE,kBAAkB,CAAC,KAAK,CAAC;QAC/B,MAAM,EAAE,IAAI,EAAE,mCAAmC;QACjD,MAAM,EAAE,aAAa,CAAC,KAAK,EAAE,OAAO,CAAC,gBAAgB,EAAE,OAAO,CAAC,aAAa,CAAC;QAC7E,QAAQ,EAAE,KAAK;QACf,WAAW,EAAE,KAAK,CAAC,qBAAuE;QAC1F,aAAa;KACd,CAAC;AACJ,CAAC","sourcesContent":["/**\n * VentureKit Request Context\n * \n * Provides typed access to request metadata, user info, and tenant context.\n * Extensible for future auth/tenancy modules.\n */\n\nimport type { APIGatewayProxyEventV2 } from 'aws-lambda';\n\n/**\n * User information extracted from JWT claims\n */\nexport interface UserContext {\n  /** User ID (Cognito sub) */\n  id: string;\n  /** User email */\n  email?: string;\n  /** User's OAuth scopes */\n  scopes: string[];\n  /** Custom claims from JWT */\n  claims: Record<string, unknown>;\n}\n\n/**\n * Tenant context for multi-tenant applications\n * (Populated by @venturekit/tenancy when enabled)\n */\nexport interface TenantContext {\n  /** Tenant ID */\n  id: string;\n  /** Tenant slug/subdomain */\n  slug?: string;\n  /** Tenant-specific metadata */\n  metadata: Record<string, unknown>;\n}\n\n/**\n * Request context passed to all handlers\n */\nexport interface RequestContext {\n  /** Unique request ID for tracing */\n  requestId: string;\n  \n  /** Request timestamp */\n  timestamp: Date;\n  \n  /** HTTP method */\n  method: string;\n  \n  /** Request path */\n  path: string;\n  \n  /** Source IP address */\n  sourceIp: string;\n  \n  /** User agent */\n  userAgent: string;\n  \n  /** User context (populated for authenticated requests) */\n  user: UserContext | null;\n  \n  /** Tenant context (populated when tenancy is enabled) */\n  tenant: TenantContext | null;\n  \n  /** Request locale (from Accept-Language or default) */\n  locale: string;\n  \n  /** Raw AWS event (for advanced use cases) */\n  rawEvent: APIGatewayProxyEventV2;\n\n  /** Query params from the request */\n  queryParams?: Record<string, string | undefined>;\n\n  /** \n   * Database transaction (populated when handler has transactional: true)\n   * Use tx.query() to run all queries within the same transaction.\n   * The transaction is auto-committed on success, rolled back on error.\n   */\n  tx?: unknown;\n\n  /**\n   * Infrastructure intent outputs (populated after infra provisioning).\n   * Provides access to provisioned resource endpoints, ARNs, etc.\n   * Hydrated from the VENTURE_INTENT_OUTPUTS environment variable.\n   */\n  intentOutputs?: Record<string, unknown>;\n}\n\n/**\n * Extract user context from JWT claims in API Gateway event\n */\nexport function extractUserContext(event: APIGatewayProxyEventV2): UserContext | null {\n  const claims = (event.requestContext as any)?.authorizer?.jwt?.claims;\n  \n  if (!claims) {\n    return null;\n  }\n  \n  const sub = claims.sub as string | undefined;\n  if (!sub) {\n    return null;\n  }\n  \n  // Extract scopes from 'scope' claim (space-separated)\n  const scopeString = claims.scope as string | undefined;\n  const scopes = scopeString ? scopeString.split(' ') : [];\n  \n  return {\n    id: sub,\n    email: claims.email as string | undefined,\n    scopes,\n    claims: claims as Record<string, unknown>,\n  };\n}\n\n/**\n * Extract locale from Accept-Language header\n */\nexport function extractLocale(\n  event: APIGatewayProxyEventV2,\n  supportedLocales: string[],\n  defaultLocale: string\n): string {\n  const acceptLanguage = event.headers?.['accept-language'] || '';\n  \n  // Parse Accept-Language header (simplified)\n  const requested = acceptLanguage.split(',')[0]?.split('-')[0]?.toLowerCase();\n  \n  if (requested && supportedLocales.includes(requested)) {\n    return requested;\n  }\n  \n  return defaultLocale;\n}\n\n/**\n * Build request context from API Gateway event\n */\nexport function buildContext(\n  event: APIGatewayProxyEventV2,\n  options: {\n    supportedLocales: string[];\n    defaultLocale: string;\n  }\n): RequestContext {\n  // Hydrate intent outputs from env var (set by infra layer after provisioning)\n  let intentOutputs: Record<string, unknown> | undefined;\n  try {\n    const raw = process.env.VENTURE_INTENT_OUTPUTS;\n    if (raw) {\n      intentOutputs = JSON.parse(raw);\n    }\n  } catch {\n    // Ignore parse errors — intentOutputs stays undefined\n  }\n\n  return {\n    requestId: event.requestContext?.requestId || crypto.randomUUID(),\n    timestamp: new Date(),\n    method: event.requestContext?.http?.method || 'UNKNOWN',\n    path: event.requestContext?.http?.path || '/',\n    sourceIp: event.requestContext?.http?.sourceIp || 'unknown',\n    userAgent: event.headers?.['user-agent'] || 'unknown',\n    user: extractUserContext(event),\n    tenant: null, // Populated by @venturekit/tenancy\n    locale: extractLocale(event, options.supportedLocales, options.defaultLocale),\n    rawEvent: event,\n    queryParams: event.queryStringParameters as Record<string, string | undefined> | undefined,\n    intentOutputs,\n  };\n}\n"]}

package/dist/errors.d.ts

@@ -0,0 +1,80 @@
+/**
+ * VentureKit Runtime Errors
+ *
+ * Standardized error types for consistent error handling across handlers.
+ */
+/**
+ * Base error class for all VentureKit errors
+ */
+export declare class VentureError extends Error {
+    readonly code: string;
+    readonly statusCode: number;
+    readonly details?: Record<string, unknown> | undefined;
+    constructor(code: string, message: string, statusCode?: number, details?: Record<string, unknown> | undefined);
+    toJSON(): {
+        error: {
+            details?: Record<string, unknown> | undefined;
+            code: string;
+            message: string;
+        };
+    };
+}
+/**
+ * 400 Bad Request - Invalid input
+ */
+export declare class BadRequestError extends VentureError {
+    constructor(message: string, details?: Record<string, unknown>);
+}
+/**
+ * 401 Unauthorized - Missing or invalid authentication
+ */
+export declare class UnauthorizedError extends VentureError {
+    constructor(message?: string);
+}
+/**
+ * 403 Forbidden - Authenticated but not allowed
+ */
+export declare class ForbiddenError extends VentureError {
+    constructor(message?: string);
+}
+/**
+ * 404 Not Found - Resource doesn't exist
+ */
+export declare class NotFoundError extends VentureError {
+    constructor(resource: string, id?: string);
+}
+/**
+ * 409 Conflict - Resource already exists or state conflict
+ */
+export declare class ConflictError extends VentureError {
+    constructor(message: string, details?: Record<string, unknown>);
+}
+/**
+ * 422 Unprocessable Entity - Validation failed
+ */
+export declare class ValidationError extends VentureError {
+    readonly fieldErrors: Record<string, string[]>;
+    constructor(message: string, fieldErrors: Record<string, string[]>);
+}
+/**
+ * 429 Too Many Requests - Rate limited
+ */
+export declare class RateLimitError extends VentureError {
+    constructor(retryAfterSec?: number);
+}
+/**
+ * 500 Internal Server Error - Unexpected error
+ */
+export declare class InternalError extends VentureError {
+    constructor(message?: string);
+}
+/**
+ * 503 Service Unavailable - Dependency failure
+ */
+export declare class ServiceUnavailableError extends VentureError {
+    constructor(service: string);
+}
+/**
+ * Check if an error is a VentureError
+ */
+export declare function isVentureError(error: unknown): error is VentureError;

package/dist/errors.js

@@ -0,0 +1,134 @@
+"use strict";
+/**
+ * VentureKit Runtime Errors
+ *
+ * Standardized error types for consistent error handling across handlers.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ServiceUnavailableError = exports.InternalError = exports.RateLimitError = exports.ValidationError = exports.ConflictError = exports.NotFoundError = exports.ForbiddenError = exports.UnauthorizedError = exports.BadRequestError = exports.VentureError = void 0;
+exports.isVentureError = isVentureError;
+/**
+ * Base error class for all VentureKit errors
+ */
+class VentureError extends Error {
+    code;
+    statusCode;
+    details;
+    constructor(code, message, statusCode = 500, details) {
+        super(message);
+        this.code = code;
+        this.statusCode = statusCode;
+        this.details = details;
+        this.name = 'VentureError';
+    }
+    toJSON() {
+        return {
+            error: {
+                code: this.code,
+                message: this.message,
+                ...(this.details && { details: this.details }),
+            },
+        };
+    }
+}
+exports.VentureError = VentureError;
+/**
+ * 400 Bad Request - Invalid input
+ */
+class BadRequestError extends VentureError {
+    constructor(message, details) {
+        super('BAD_REQUEST', message, 400, details);
+        this.name = 'BadRequestError';
+    }
+}
+exports.BadRequestError = BadRequestError;
+/**
+ * 401 Unauthorized - Missing or invalid authentication
+ */
+class UnauthorizedError extends VentureError {
+    constructor(message = 'Authentication required') {
+        super('UNAUTHORIZED', message, 401);
+        this.name = 'UnauthorizedError';
+    }
+}
+exports.UnauthorizedError = UnauthorizedError;
+/**
+ * 403 Forbidden - Authenticated but not allowed
+ */
+class ForbiddenError extends VentureError {
+    constructor(message = 'Access denied') {
+        super('FORBIDDEN', message, 403);
+        this.name = 'ForbiddenError';
+    }
+}
+exports.ForbiddenError = ForbiddenError;
+/**
+ * 404 Not Found - Resource doesn't exist
+ */
+class NotFoundError extends VentureError {
+    constructor(resource, id) {
+        const message = id ? `${resource} '${id}' not found` : `${resource} not found`;
+        super('NOT_FOUND', message, 404, { resource, id });
+        this.name = 'NotFoundError';
+    }
+}
+exports.NotFoundError = NotFoundError;
+/**
+ * 409 Conflict - Resource already exists or state conflict
+ */
+class ConflictError extends VentureError {
+    constructor(message, details) {
+        super('CONFLICT', message, 409, details);
+        this.name = 'ConflictError';
+    }
+}
+exports.ConflictError = ConflictError;
+/**
+ * 422 Unprocessable Entity - Validation failed
+ */
+class ValidationError extends VentureError {
+    fieldErrors;
+    constructor(message, fieldErrors) {
+        super('VALIDATION_ERROR', message, 422, { fields: fieldErrors });
+        this.fieldErrors = fieldErrors;
+        this.name = 'ValidationError';
+    }
+}
+exports.ValidationError = ValidationError;
+/**
+ * 429 Too Many Requests - Rate limited
+ */
+class RateLimitError extends VentureError {
+    constructor(retryAfterSec) {
+        super('RATE_LIMITED', 'Too many requests', 429, retryAfterSec ? { retryAfterSec } : undefined);
+        this.name = 'RateLimitError';
+    }
+}
+exports.RateLimitError = RateLimitError;
+/**
+ * 500 Internal Server Error - Unexpected error
+ */
+class InternalError extends VentureError {
+    constructor(message = 'Internal server error') {
+        super('INTERNAL_ERROR', message, 500);
+        this.name = 'InternalError';
+    }
+}
+exports.InternalError = InternalError;
+/**
+ * 503 Service Unavailable - Dependency failure
+ */
+class ServiceUnavailableError extends VentureError {
+    constructor(service) {
+        super('SERVICE_UNAVAILABLE', `${service} is currently unavailable`, 503, { service });
+        this.name = 'ServiceUnavailableError';
+    }
+}
+exports.ServiceUnavailableError = ServiceUnavailableError;
+/**
+ * Check if an error is a VentureError
+ */
+function isVentureError(error) {
+    return error instanceof VentureError;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"errors.js","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * VentureKit Runtime Errors\n * \n * Standardized error types for consistent error handling across handlers.\n */\n\n/**\n * Base error class for all VentureKit errors\n */\nexport class VentureError extends Error {\n  constructor(\n    public readonly code: string,\n    message: string,\n    public readonly statusCode: number = 500,\n    public readonly details?: Record<string, unknown>\n  ) {\n    super(message);\n    this.name = 'VentureError';\n  }\n\n  toJSON() {\n    return {\n      error: {\n        code: this.code,\n        message: this.message,\n        ...(this.details && { details: this.details }),\n      },\n    };\n  }\n}\n\n/**\n * 400 Bad Request - Invalid input\n */\nexport class BadRequestError extends VentureError {\n  constructor(message: string, details?: Record<string, unknown>) {\n    super('BAD_REQUEST', message, 400, details);\n    this.name = 'BadRequestError';\n  }\n}\n\n/**\n * 401 Unauthorized - Missing or invalid authentication\n */\nexport class UnauthorizedError extends VentureError {\n  constructor(message: string = 'Authentication required') {\n    super('UNAUTHORIZED', message, 401);\n    this.name = 'UnauthorizedError';\n  }\n}\n\n/**\n * 403 Forbidden - Authenticated but not allowed\n */\nexport class ForbiddenError extends VentureError {\n  constructor(message: string = 'Access denied') {\n    super('FORBIDDEN', message, 403);\n    this.name = 'ForbiddenError';\n  }\n}\n\n/**\n * 404 Not Found - Resource doesn't exist\n */\nexport class NotFoundError extends VentureError {\n  constructor(resource: string, id?: string) {\n    const message = id ? `${resource} '${id}' not found` : `${resource} not found`;\n    super('NOT_FOUND', message, 404, { resource, id });\n    this.name = 'NotFoundError';\n  }\n}\n\n/**\n * 409 Conflict - Resource already exists or state conflict\n */\nexport class ConflictError extends VentureError {\n  constructor(message: string, details?: Record<string, unknown>) {\n    super('CONFLICT', message, 409, details);\n    this.name = 'ConflictError';\n  }\n}\n\n/**\n * 422 Unprocessable Entity - Validation failed\n */\nexport class ValidationError extends VentureError {\n  constructor(\n    message: string,\n    public readonly fieldErrors: Record<string, string[]>\n  ) {\n    super('VALIDATION_ERROR', message, 422, { fields: fieldErrors });\n    this.name = 'ValidationError';\n  }\n}\n\n/**\n * 429 Too Many Requests - Rate limited\n */\nexport class RateLimitError extends VentureError {\n  constructor(retryAfterSec?: number) {\n    super('RATE_LIMITED', 'Too many requests', 429, \n      retryAfterSec ? { retryAfterSec } : undefined\n    );\n    this.name = 'RateLimitError';\n  }\n}\n\n/**\n * 500 Internal Server Error - Unexpected error\n */\nexport class InternalError extends VentureError {\n  constructor(message: string = 'Internal server error') {\n    super('INTERNAL_ERROR', message, 500);\n    this.name = 'InternalError';\n  }\n}\n\n/**\n * 503 Service Unavailable - Dependency failure\n */\nexport class ServiceUnavailableError extends VentureError {\n  constructor(service: string) {\n    super('SERVICE_UNAVAILABLE', `${service} is currently unavailable`, 503, { service });\n    this.name = 'ServiceUnavailableError';\n  }\n}\n\n/**\n * Check if an error is a VentureError\n */\nexport function isVentureError(error: unknown): error is VentureError {\n  return error instanceof VentureError;\n}\n"]}

package/dist/handler.d.ts

@@ -0,0 +1,71 @@
+/**
+ * VentureKit Handler
+ *
+ * Single unified Lambda handler that adapts to context:
+ * - No scopes = public endpoint
+ * - With scopes = authenticated + scope check
+ * - Status code auto-detected from HTTP method or explicitly set
+ */
+import type { APIGatewayProxyEventV2, APIGatewayProxyResultV2, Context } from 'aws-lambda';
+import { RequestContext } from './context';
+import { Logger } from './logger';
+import { Middleware } from './middleware';
+/**
+ * Handler function signature
+ */
+export type HandlerFn<TBody = unknown, TResult = unknown> = (body: TBody, ctx: RequestContext, logger: Logger) => Promise<TResult>;
+/**
+ * HTTP Status codes
+ */
+export type StatusCode = 200 | 201 | 204;
+/**
+ * Handler configuration
+ */
+export interface HandlerConfig {
+    /**
+     * Required OAuth scopes
+     * - Empty array or undefined = public endpoint (no auth)
+     * - Non-empty array = authenticated + scope check
+     */
+    scopes?: string[];
+    /**
+     * Response status code
+     * - undefined = auto-detect from HTTP method (GET/PUT=200, POST=201, DELETE=204)
+     * - number = explicit status code
+     */
+    status?: StatusCode;
+    /** Custom middleware to apply */
+    middleware?: Middleware[];
+    /** Log level */
+    logLevel?: 'debug' | 'info' | 'warn' | 'error';
+    /**
+     * Wrap the entire handler execution in a database transaction.
+     * When true, a transaction is started before the handler runs
+     * and is available via ctx.tx. It auto-commits on success
+     * and auto-rolls-back on error.
+     * Requires @venturekit/data to be installed.
+     */
+    transactional?: boolean;
+}
+/**
+ * VentureKit unified handler
+ *
+ * Adapts to context with smart defaults:
+ * - No scopes = public endpoint
+ * - With scopes = authenticated + scope check
+ * - Status: GET/PUT → 200, POST → 201, DELETE → 204 (or set explicitly)
+ *
+ * @example
+ * ```typescript
+ * // Public endpoint
+ * export const main = handler(async (body, ctx, log) => {
+ *   return { status: 'ok' };
+ * });
+ *
+ * // Authenticated endpoint
+ * export const main = handler(async (body, ctx, log) => {
+ *   return { id: '123' };
+ * }, { scopes: ['projects.write'] });
+ * ```
+ */
+export declare function handler<TBody = unknown, TResult = unknown>(fn: HandlerFn<TBody, TResult>, config?: HandlerConfig): (event: APIGatewayProxyEventV2, context: Context) => Promise<APIGatewayProxyResultV2>;