@venturekit/infra 0.0.0-dev.20260307234057

package/dist/translators/storage.js

@@ -0,0 +1,48 @@
+"use strict";
+/**
+ * Storage Intent Translator
+ *
+ * Translates StorageIntent to SST S3/CDN resources.
+ * This file isolates all SST/S3-specific logic.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.translateStorage = translateStorage;
+/**
+ * Translate StorageIntent to SST Bucket
+ */
+async function translateStorage(intent, sst, projectName) {
+    const resourceName = `${projectName}-${intent.id}`;
+    // Build bucket configuration based on intent
+    const bucketConfig = {};
+    // Versioning based on purpose or explicit setting
+    if (intent.versioned ?? intent.purpose === 'backups') {
+        bucketConfig.versioning = true;
+    }
+    // CORS configuration
+    if (intent.corsOrigins && intent.corsOrigins.length > 0) {
+        bucketConfig.cors = {
+            allowOrigins: intent.corsOrigins,
+            allowMethods: ['GET', 'PUT', 'POST', 'DELETE'],
+            allowHeaders: ['*'],
+        };
+    }
+    // Create bucket
+    const bucket = new sst.Bucket(resourceName, bucketConfig);
+    const output = {
+        bucketName: bucket.name,
+        bucketArn: bucket.arn,
+    };
+    // Create CDN if requested
+    if (intent.cdn) {
+        const cdnConfig = {
+            origins: [{ bucket }],
+        };
+        if (intent.cdnDomain) {
+            cdnConfig.domain = intent.cdnDomain;
+        }
+        const cdn = new sst.Cdn(`${resourceName}-cdn`, cdnConfig);
+        output.cdnUrl = cdn.url;
+    }
+    return output;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/venture.d.ts

@@ -0,0 +1,89 @@
+/**
+ * VentureKit Main Entry Point
+ *
+ * defineVenture() is the primary API for creating VentureKit applications.
+ * Consumers never see the underlying infrastructure tooling.
+ */
+import { BaseConfig, SecurityConfig, EnvConfigInput, ResolvedConfig, VentureIntent } from '@venturekit/core';
+/**
+ * VentureKit application definition
+ */
+export interface VentureDefinition {
+    /** Base configuration (project identity) */
+    base: BaseConfig;
+    /** Security configuration (scopes, clients) */
+    security: SecurityConfig;
+    /** Environment-specific configurations */
+    envs: {
+        dev?: EnvConfigInput;
+        stage?: EnvConfigInput;
+        prod?: EnvConfigInput;
+    };
+    /** Path to routes directory (relative to project root) - REQUIRED */
+    routesDir: string;
+    /**
+     * Infrastructure intents
+     *
+     * Declare WHAT infrastructure you need, not HOW to build it.
+     * VentureKit translates intents to provider-specific resources.
+     *
+     * @example
+     * ```typescript
+     * infrastructure: {
+     *   databases: [{ id: 'main', type: 'postgres', size: 'small', name: 'mydb' }],
+     *   storage: [{ id: 'uploads', purpose: 'uploads', cdn: true }],
+     * }
+     * ```
+     */
+    infrastructure?: VentureIntent;
+}
+/**
+ * VentureKit app configuration
+ */
+export interface VentureAppConfig {
+    name: string;
+    home: 'aws';
+    providers: {
+        aws: {
+            region: string;
+        };
+    };
+}
+/**
+ * Define a VentureKit application
+ *
+ * This is the main entry point for VentureKit projects.
+ *
+ * @example
+ * ```typescript
+ * // venturekit.config.ts
+ * import { defineVenture } from '@venturekit/infra';
+ * import { base } from './config/base';
+ * import { security } from './config/security';
+ * import { dev } from './config/dev';
+ * import { prod } from './config/prod';
+ *
+ * export default defineVenture({
+ *   base,
+ *   security,
+ *   envs: { dev, prod },
+ *   routesDir: 'src/routes',
+ * });
+ * ```
+ */
+export declare function defineVenture(definition: VentureDefinition): {
+    name: string;
+    home: "aws";
+    providers: {
+        aws: {
+            region: string;
+        };
+    };
+    run(): Promise<Record<string, unknown>>;
+};
+/**
+ * Get resolved configuration for current environment
+ *
+ * Useful for accessing config values in handlers or other code.
+ */
+export declare function getResolvedConfig(base: BaseConfig, security: SecurityConfig, envInput: EnvConfigInput): ResolvedConfig;

package/dist/venture.js

@@ -0,0 +1,229 @@
+"use strict";
+/**
+ * VentureKit Main Entry Point
+ *
+ * defineVenture() is the primary API for creating VentureKit applications.
+ * Consumers never see the underlying infrastructure tooling.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defineVenture = defineVenture;
+exports.getResolvedConfig = getResolvedConfig;
+const core_1 = require("@venturekit/core");
+const translators_1 = require("./translators");
+const lambda_1 = require("./constructs/lambda");
+const api_1 = require("./constructs/api");
+const vpc_1 = require("./constructs/vpc");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+/**
+ * Discover routes from file system
+ *
+ * Convention:
+ * - src/routes/health/get.ts -> GET /health
+ * - src/routes/projects/post.ts -> POST /projects
+ * - src/routes/projects/[id]/get.ts -> GET /projects/{id}
+ * - src/routes/projects/[id]/delete.ts -> DELETE /projects/{id}
+ */
+function discoverRoutes(routesDir) {
+    const routes = [];
+    function scanDir(dir, routePath = '') {
+        if (!fs.existsSync(dir))
+            return;
+        const entries = fs.readdirSync(dir, { withFileTypes: true });
+        for (const entry of entries) {
+            const fullPath = path.join(dir, entry.name);
+            if (entry.isDirectory()) {
+                // Convert [param] to {param} for API Gateway
+                const segment = entry.name.startsWith('[') && entry.name.endsWith(']')
+                    ? `{${entry.name.slice(1, -1)}}`
+                    : entry.name;
+                scanDir(fullPath, `${routePath}/${segment}`);
+            }
+            else if (entry.isFile() && (entry.name.endsWith('.ts') || entry.name.endsWith('.js'))) {
+                const method = (0, api_1.fileNameToMethod)(entry.name);
+                if (method) {
+                    const apiPath = routePath || '/';
+                    const handlerPath = fullPath.replace(/\.(ts|js)$/, '.handler');
+                    routes.push({ method, path: apiPath, handler: handlerPath });
+                }
+            }
+        }
+    }
+    scanDir(routesDir);
+    return routes;
+}
+/**
+ * Define a VentureKit application
+ *
+ * This is the main entry point for VentureKit projects.
+ *
+ * @example
+ * ```typescript
+ * // venturekit.config.ts
+ * import { defineVenture } from '@venturekit/infra';
+ * import { base } from './config/base';
+ * import { security } from './config/security';
+ * import { dev } from './config/dev';
+ * import { prod } from './config/prod';
+ *
+ * export default defineVenture({
+ *   base,
+ *   security,
+ *   envs: { dev, prod },
+ *   routesDir: 'src/routes',
+ * });
+ * ```
+ */
+function defineVenture(definition) {
+    // Validate configs
+    const baseValidation = (0, core_1.validateBaseConfig)(definition.base);
+    (0, core_1.assertValid)(baseValidation);
+    const securityValidation = (0, core_1.validateSecurityConfig)(definition.security);
+    (0, core_1.assertValid)(securityValidation);
+    return {
+        name: definition.base.name,
+        home: 'aws',
+        providers: {
+            aws: {
+                region: definition.base.region,
+            },
+        },
+        async run() {
+            // Determine current environment from VENTURE_STAGE (not SST)
+            const stage = process.env.VENTURE_STAGE || 'dev';
+            const env = (stage === 'prod' ? 'prod' : stage === 'stage' ? 'stage' : 'dev');
+            // Get env config (default to empty if not specified)
+            const envInput = definition.envs[env] || {};
+            // Validate env config
+            const envValidation = (0, core_1.validateEnvConfigInput)(env, envInput);
+            (0, core_1.assertValid)(envValidation);
+            // Resolve full configuration
+            const config = (0, core_1.resolveConfig)(definition.base, definition.security, env, envInput);
+            // Discover routes from file system
+            const routes = discoverRoutes(definition.routesDir);
+            // Translate infrastructure intents if provided
+            let intentOutputs;
+            if (definition.infrastructure) {
+                intentOutputs = await (0, translators_1.translateAllIntents)(definition.infrastructure, config.name);
+            }
+            // Create infrastructure (passes intent outputs to Lambda env)
+            const resources = await createInfrastructure(config, routes, intentOutputs);
+            if (intentOutputs) {
+                resources.infrastructure = intentOutputs;
+            }
+            return resources;
+        },
+    };
+}
+/**
+ * Create infrastructure resources
+ */
+async function createInfrastructure(config, routes, intentOutputs) {
+    // Dynamic import of infrastructure tooling (hidden from consumers)
+    const infra = await Promise.resolve().then(() => __importStar(require('sst')));
+    const outputs = {};
+    // Create VPC if needed
+    let vpc = undefined;
+    if ((0, vpc_1.isVpcRequired)(config.lambda.vpcEnabled)) {
+        vpc = new infra.Vpc(`${config.name}-vpc`, (0, vpc_1.createVpcConfig)(config.name, config.vpc));
+        outputs.vpcId = vpc.id;
+    }
+    // Build route configuration
+    const routeConfig = {};
+    for (const route of routes) {
+        const key = `${route.method} ${route.path}`;
+        const routeEntry = {
+            handler: route.handler,
+            ...(0, lambda_1.createLambdaConfig)(config.lambda),
+            environment: (0, lambda_1.createLambdaEnvironment)({
+                VENTURE_ENV: config.env,
+                VENTURE_NAME: config.name,
+                ...(intentOutputs ? { VENTURE_INTENT_OUTPUTS: JSON.stringify(intentOutputs) } : {}),
+            }),
+        };
+        if (vpc && config.lambda.vpcEnabled) {
+            routeEntry.vpc = vpc;
+        }
+        routeConfig[key] = routeEntry;
+    }
+    // Create API Gateway
+    const corsConfig = (0, api_1.createCorsConfig)(config.api.cors);
+    const apiConfig = {
+        routes: routeConfig,
+    };
+    if (corsConfig) {
+        apiConfig.cors = corsConfig;
+    }
+    // Add custom domain if configured
+    if (config.api.customDomain) {
+        apiConfig.domain = {
+            name: config.api.customDomain.domainName,
+            cert: config.api.customDomain.certificateArn,
+        };
+    }
+    const api = new infra.ApiGatewayV2(`${config.name}-api`, apiConfig);
+    outputs.apiUrl = api.url;
+    // Create WebSocket API if enabled
+    if (config.websocket.enabled) {
+        const wsApi = new infra.ApiGatewayWebSocket(`${config.name}-ws`, {
+            routes: {
+                $connect: `${config.name}/ws/connect.handler`,
+                $disconnect: `${config.name}/ws/disconnect.handler`,
+                $default: `${config.name}/ws/default.handler`,
+            },
+        });
+        outputs.wsUrl = wsApi.url;
+    }
+    // Output resolved config for debugging
+    outputs.config = {
+        name: config.name,
+        env: config.env,
+        dataSafety: config.dataSafety,
+        routeCount: routes.length,
+    };
+    return outputs;
+}
+/**
+ * Get resolved configuration for current environment
+ *
+ * Useful for accessing config values in handlers or other code.
+ */
+function getResolvedConfig(base, security, envInput) {
+    const stage = process.env.VENTURE_STAGE || 'dev';
+    const env = (stage === 'prod' ? 'prod' : stage === 'stage' ? 'stage' : 'dev');
+    return (0, core_1.resolveConfig)(base, security, env, envInput);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"venture.js","sourceRoot":"","sources":["../src/venture.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * VentureKit Main Entry Point\n * \n * defineVenture() is the primary API for creating VentureKit applications.\n * Consumers never see the underlying infrastructure tooling.\n */\n\nimport {\n  BaseConfig,\n  SecurityConfig,\n  EnvConfigInput,\n  Environment,\n  ResolvedConfig,\n  VentureIntent,\n  IntentOutputs,\n  resolveConfig,\n  validateBaseConfig,\n  validateSecurityConfig,\n  validateEnvConfigInput,\n  assertValid,\n} from '@venturekit/core';\n\nimport { translateAllIntents } from './translators';\n\nimport {\n  createLambdaConfig,\n  createLambdaEnvironment,\n} from './constructs/lambda';\n\nimport {\n  createCorsConfig,\n  dirPathToRoutePath,\n  fileNameToMethod,\n} from './constructs/api';\n\nimport {\n  createVpcConfig,\n  isVpcRequired,\n} from './constructs/vpc';\n\nimport * as fs from 'fs';\nimport * as path from 'path';\n\n/**\n * VentureKit application definition\n */\nexport interface VentureDefinition {\n  /** Base configuration (project identity) */\n  base: BaseConfig;\n  \n  /** Security configuration (scopes, clients) */\n  security: SecurityConfig;\n  \n  /** Environment-specific configurations */\n  envs: {\n    dev?: EnvConfigInput;\n    stage?: EnvConfigInput;\n    prod?: EnvConfigInput;\n  };\n  \n  /** Path to routes directory (relative to project root) - REQUIRED */\n  routesDir: string;\n  \n  /**\n   * Infrastructure intents\n   * \n   * Declare WHAT infrastructure you need, not HOW to build it.\n   * VentureKit translates intents to provider-specific resources.\n   * \n   * @example\n   * ```typescript\n   * infrastructure: {\n   *   databases: [{ id: 'main', type: 'postgres', size: 'small', name: 'mydb' }],\n   *   storage: [{ id: 'uploads', purpose: 'uploads', cdn: true }],\n   * }\n   * ```\n   */\n  infrastructure?: VentureIntent;\n}\n\n/**\n * VentureKit app configuration\n */\nexport interface VentureAppConfig {\n  name: string;\n  home: 'aws';\n  providers: {\n    aws: {\n      region: string;\n    };\n  };\n}\n\n/**\n * Discover routes from file system\n * \n * Convention:\n * - src/routes/health/get.ts -> GET /health\n * - src/routes/projects/post.ts -> POST /projects\n * - src/routes/projects/[id]/get.ts -> GET /projects/{id}\n * - src/routes/projects/[id]/delete.ts -> DELETE /projects/{id}\n */\nfunction discoverRoutes(routesDir: string): Array<{ method: string; path: string; handler: string }> {\n  const routes: Array<{ method: string; path: string; handler: string }> = [];\n  \n  function scanDir(dir: string, routePath: string = '') {\n    if (!fs.existsSync(dir)) return;\n    \n    const entries = fs.readdirSync(dir, { withFileTypes: true });\n    \n    for (const entry of entries) {\n      const fullPath = path.join(dir, entry.name);\n      \n      if (entry.isDirectory()) {\n        // Convert [param] to {param} for API Gateway\n        const segment = entry.name.startsWith('[') && entry.name.endsWith(']')\n          ? `{${entry.name.slice(1, -1)}}`\n          : entry.name;\n        scanDir(fullPath, `${routePath}/${segment}`);\n      } else if (entry.isFile() && (entry.name.endsWith('.ts') || entry.name.endsWith('.js'))) {\n        const method = fileNameToMethod(entry.name);\n        if (method) {\n          const apiPath = routePath || '/';\n          const handlerPath = fullPath.replace(/\\.(ts|js)$/, '.handler');\n          routes.push({ method, path: apiPath, handler: handlerPath });\n        }\n      }\n    }\n  }\n  \n  scanDir(routesDir);\n  return routes;\n}\n\n/**\n * Define a VentureKit application\n * \n * This is the main entry point for VentureKit projects.\n * \n * @example\n * ```typescript\n * // venturekit.config.ts\n * import { defineVenture } from '@venturekit/infra';\n * import { base } from './config/base';\n * import { security } from './config/security';\n * import { dev } from './config/dev';\n * import { prod } from './config/prod';\n * \n * export default defineVenture({\n *   base,\n *   security,\n *   envs: { dev, prod },\n *   routesDir: 'src/routes',\n * });\n * ```\n */\nexport function defineVenture(definition: VentureDefinition) {\n  // Validate configs\n  const baseValidation = validateBaseConfig(definition.base);\n  assertValid(baseValidation);\n  \n  const securityValidation = validateSecurityConfig(definition.security);\n  assertValid(securityValidation);\n\n  return {\n    name: definition.base.name,\n    home: 'aws' as const,\n    providers: {\n      aws: {\n        region: definition.base.region,\n      },\n    },\n    async run() {\n      // Determine current environment from VENTURE_STAGE (not SST)\n      const stage = process.env.VENTURE_STAGE || 'dev';\n      const env = (stage === 'prod' ? 'prod' : stage === 'stage' ? 'stage' : 'dev') as Environment;\n      \n      // Get env config (default to empty if not specified)\n      const envInput = definition.envs[env] || {};\n      \n      // Validate env config\n      const envValidation = validateEnvConfigInput(env, envInput);\n      assertValid(envValidation);\n      \n      // Resolve full configuration\n      const config = resolveConfig(definition.base, definition.security, env, envInput);\n      \n      // Discover routes from file system\n      const routes = discoverRoutes(definition.routesDir);\n      \n      // Translate infrastructure intents if provided\n      let intentOutputs: IntentOutputs | undefined;\n      if (definition.infrastructure) {\n        intentOutputs = await translateAllIntents(\n          definition.infrastructure,\n          config.name\n        );\n      }\n\n      // Create infrastructure (passes intent outputs to Lambda env)\n      const resources = await createInfrastructure(config, routes, intentOutputs);\n\n      if (intentOutputs) {\n        resources.infrastructure = intentOutputs;\n      }\n      \n      return resources;\n    },\n  };\n}\n\n/**\n * Create infrastructure resources\n */\nasync function createInfrastructure(\n  config: ResolvedConfig,\n  routes: Array<{ method: string; path: string; handler: string }>,\n  intentOutputs?: IntentOutputs,\n) {\n  // Dynamic import of infrastructure tooling (hidden from consumers)\n  const infra = await import('sst') as any;\n  \n  const outputs: Record<string, unknown> = {};\n  \n  // Create VPC if needed\n  let vpc: unknown = undefined;\n  if (isVpcRequired(config.lambda.vpcEnabled)) {\n    vpc = new infra.Vpc(`${config.name}-vpc`, createVpcConfig(config.name, config.vpc));\n    outputs.vpcId = (vpc as { id: string }).id;\n  }\n  \n  // Build route configuration\n  const routeConfig: Record<string, unknown> = {};\n  \n  for (const route of routes) {\n    const key = `${route.method} ${route.path}`;\n    const routeEntry: Record<string, unknown> = {\n      handler: route.handler,\n      ...createLambdaConfig(config.lambda),\n      environment: createLambdaEnvironment({\n        VENTURE_ENV: config.env,\n        VENTURE_NAME: config.name,\n        ...(intentOutputs ? { VENTURE_INTENT_OUTPUTS: JSON.stringify(intentOutputs) } : {}),\n      }),\n    };\n    if (vpc && config.lambda.vpcEnabled) {\n      routeEntry.vpc = vpc;\n    }\n    routeConfig[key] = routeEntry;\n  }\n  \n  // Create API Gateway\n  const corsConfig = createCorsConfig(config.api.cors);\n  \n  const apiConfig: Record<string, unknown> = {\n    routes: routeConfig,\n  };\n  \n  if (corsConfig) {\n    apiConfig.cors = corsConfig;\n  }\n  \n  // Add custom domain if configured\n  if (config.api.customDomain) {\n    apiConfig.domain = {\n      name: config.api.customDomain.domainName,\n      cert: config.api.customDomain.certificateArn,\n    };\n  }\n  \n  const api = new infra.ApiGatewayV2(`${config.name}-api`, apiConfig);\n  \n  outputs.apiUrl = (api as { url: string }).url;\n  \n  // Create WebSocket API if enabled\n  if (config.websocket.enabled) {\n    const wsApi = new infra.ApiGatewayWebSocket(`${config.name}-ws`, {\n      routes: {\n        $connect: `${config.name}/ws/connect.handler`,\n        $disconnect: `${config.name}/ws/disconnect.handler`,\n        $default: `${config.name}/ws/default.handler`,\n      },\n    });\n    outputs.wsUrl = (wsApi as { url: string }).url;\n  }\n  \n  // Output resolved config for debugging\n  outputs.config = {\n    name: config.name,\n    env: config.env,\n    dataSafety: config.dataSafety,\n    routeCount: routes.length,\n  };\n  \n  return outputs;\n}\n\n/**\n * Get resolved configuration for current environment\n * \n * Useful for accessing config values in handlers or other code.\n */\nexport function getResolvedConfig(\n  base: BaseConfig,\n  security: SecurityConfig,\n  envInput: EnvConfigInput\n): ResolvedConfig {\n  const stage = process.env.VENTURE_STAGE || 'dev';\n  const env = (stage === 'prod' ? 'prod' : stage === 'stage' ? 'stage' : 'dev') as Environment;\n  return resolveConfig(base, security, env, envInput);\n}\n"]}

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "@venturekit/infra",
+  "version": "0.0.0-dev.20260307234057",
+  "description": "VentureKit infrastructure - SST constructs for AWS",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/venturekit-dev/venturekit.private.git",
+    "directory": "packages/infra"
+  },
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org",
+    "access": "public"
+  },
+  "keywords": [
+    "venturekit",
+    "saas",
+    "sst",
+    "aws",
+    "infrastructure"
+  ],
+  "license": "Apache-2.0",
+  "dependencies": {
+    "@venturekit/core": "0.0.0-dev.20260307234057",
+    "sst": "^3.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.10.0",
+    "typescript": "^5.3.0"
+  },
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "clean": "rm -rf dist"
+  }
+}