@crossdelta/infrastructure 0.1.35

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Crossdelta
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,173 @@
+# @crossdelta/infrastructure# @crossdelta/infrastructure
+
+
+
+[![npm version](https://img.shields.io/npm/v/@crossdelta/infrastructure.svg)](https://www.npmjs.com/package/@crossdelta/infrastructure)To install dependencies:
+
+[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](https://opensource.org/licenses/MIT)
+
+# Install Pulumi
+
+> 🏗️ Infrastructure-as-Code helpers for deploying microservices to DigitalOcean App Platform with Pulumi```bash
+
+curl -fsSL https://get.pulumi.com | sh
+
+## Features```
+
+
+
+- 🚀 **Service Discovery** - Auto-discover service configs from `infra/services/*.ts````bash
+
+- 🔧 **Type-safe Config** - Full TypeScript support with `ServiceConfig` typebun install
+
+- 🌐 **Smart Routing** - Automatic ingress rules for public services```
+
+- 🔒 **Internal Services** - Support for internal-only ports (no public exposure)
+
+- 📦 **Multi-Registry** - Docker Hub, GHCR, and DOCR image supportTo run:
+
+- 🔗 **URL Generation** - Auto-generate service URLs and port env vars
+
+```bash
+
+## Installationbun run index.ts
+
+```
+
+```bash
+
+npm install @crossdelta/infrastructureThis project was created using `bun init` in bun v1.3.3. [Bun](https://bun.com) is a fast all-in-one JavaScript runtime.
+
+# or
+bun add @crossdelta/infrastructure
+```
+
+## Quick Start
+
+### 1. Create a service config
+
+```typescript
+// infra/services/api-gateway.ts
+import type { ServiceConfig } from '@crossdelta/infrastructure'
+
+const config: ServiceConfig = {
+  name: 'api-gateway',
+  instanceSizeSlug: 'apps-s-1vcpu-0.5gb',
+  httpPort: 4000,
+  ingressPrefix: '/api',
+}
+
+export default config
+```
+
+### 2. Create your Pulumi entry point
+
+```typescript
+// infra/index.ts
+import { join } from 'node:path'
+import {
+  buildServices,
+  buildIngressRules,
+  buildServiceUrlEnvs,
+  buildServicePortEnvs,
+  discoverServices,
+} from '@crossdelta/infrastructure'
+import { App } from '@pulumi/digitalocean'
+
+const serviceConfigs = discoverServices(join(__dirname, 'services'))
+
+const app = new App('my-app', {
+  spec: {
+    name: 'my-platform',
+    region: 'fra',
+    envs: [
+      ...buildServiceUrlEnvs(serviceConfigs),
+      ...buildServicePortEnvs(serviceConfigs),
+    ],
+    services: buildServices({ serviceConfigs, registryCredentials, logtailToken }),
+    ingress: { rules: buildIngressRules(serviceConfigs) },
+  },
+})
+```
+
+## Service Configuration
+
+### Public Service (with ingress)
+
+```typescript
+const config: ServiceConfig = {
+  name: 'storefront',
+  httpPort: 3000,
+  ingressPrefix: '/',
+  instanceSizeSlug: 'apps-s-1vcpu-1gb',
+}
+```
+
+### Internal-only Service
+
+```typescript
+const config: ServiceConfig = {
+  name: 'orders',
+  internalPorts: [4001],
+  instanceSizeSlug: 'apps-s-1vcpu-0.5gb',
+}
+```
+
+### Custom Protocol (e.g., NATS)
+
+```typescript
+const config: ServiceConfig = {
+  name: 'nats',
+  internalPorts: [4222, 8222],
+  internalUrl: 'nats://nats:4222',
+  image: dockerHubImage('nats', '2.10-alpine'),
+}
+```
+
+## Runtime Helpers
+
+Read service configuration in your app at runtime:
+
+```typescript
+import { getServicePort, getServiceUrl } from '@crossdelta/infrastructure/env'
+
+const port = getServicePort('api-gateway', 4000)
+const ordersUrl = getServiceUrl('orders')
+```
+
+## API Reference
+
+### Service Discovery
+
+| Function | Description |
+|----------|-------------|
+| `discoverServices(dir)` | Auto-discover all `*.ts` service configs in a directory |
+
+### Builders
+
+| Function | Description |
+|----------|-------------|
+| `buildServices(opts)` | Build DO App spec services array |
+| `buildIngressRules(configs)` | Build ingress rules for public services |
+| `buildServiceUrlEnvs(configs)` | Generate `<SERVICE>_URL` env vars |
+| `buildServicePortEnvs(configs)` | Generate `<SERVICE>_PORT` env vars |
+| `buildInternalUrls(configs)` | Get internal URLs for all services |
+| `buildExternalUrls(configs, baseUrl)` | Get external URLs for public services |
+
+### Image Helpers
+
+| Function | Description |
+|----------|-------------|
+| `dockerHubImage(repo, tag)` | Create Docker Hub image config |
+| `ghcrImage(repo, tag)` | Create GHCR image config |
+
+### Runtime (import from `/env`)
+
+| Function | Description |
+|----------|-------------|
+| `getServicePort(name, default?)` | Read `<SERVICE>_PORT` from env |
+| `getServiceUrl(name)` | Read `<SERVICE>_URL` from env |
+
+## License
+
+MIT © [Crossdelta](https://github.com/crossdelta)

package/dist/env.cjs

@@ -0,0 +1,53 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __moduleCache = /* @__PURE__ */ new WeakMap;
+var __toCommonJS = (from) => {
+  var entry = __moduleCache.get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function")
+    __getOwnPropNames(from).map((key) => !__hasOwnProp.call(entry, key) && __defProp(entry, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    }));
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+
+// lib/env.ts
+var exports_env = {};
+__export(exports_env, {
+  getServiceUrl: () => getServiceUrl,
+  getServicePort: () => getServicePort
+});
+module.exports = __toCommonJS(exports_env);
+
+// lib/helpers/service-runtime.ts
+var toEnvKey = (name) => name.toUpperCase().replace(/-/g, "_");
+function getServicePort(serviceName, defaultPort = 8080) {
+  const envKey = `${toEnvKey(serviceName)}_PORT`;
+  const envValue = process.env[envKey];
+  if (envValue) {
+    const parsed = Number(envValue);
+    if (!Number.isNaN(parsed)) {
+      return parsed;
+    }
+  }
+  return defaultPort;
+}
+function getServiceUrl(serviceName) {
+  const envKey = `${toEnvKey(serviceName)}_URL`;
+  return process.env[envKey];
+}

package/dist/env.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Environment helpers for services to read configuration.
+ * Use this entry point in production services (Node.js, NestJS, etc.)
+ *
+ * @example
+ * import { getServicePort, getServiceUrl } from '@crossdelta/infrastructure/env'
+ */
+export * from './helpers/service-runtime';
+export type { ServiceName } from './types/service-names';

package/dist/env.js

@@ -0,0 +1,21 @@
+// lib/helpers/service-runtime.ts
+var toEnvKey = (name) => name.toUpperCase().replace(/-/g, "_");
+function getServicePort(serviceName, defaultPort = 8080) {
+  const envKey = `${toEnvKey(serviceName)}_PORT`;
+  const envValue = process.env[envKey];
+  if (envValue) {
+    const parsed = Number(envValue);
+    if (!Number.isNaN(parsed)) {
+      return parsed;
+    }
+  }
+  return defaultPort;
+}
+function getServiceUrl(serviceName) {
+  const envKey = `${toEnvKey(serviceName)}_URL`;
+  return process.env[envKey];
+}
+export {
+  getServiceUrl,
+  getServicePort
+};

package/dist/helpers/config.d.ts

@@ -0,0 +1,29 @@
+import type { Input } from '@pulumi/pulumi';
+/**
+ * Ensures that a string ends with a dot (useful for DNS CNAME values).
+ */
+export declare const ensureDot: (str: string) => string;
+/**
+ * Common alert configuration for services
+ */
+export declare const defaultAlerts: {
+    rule: string;
+    operator: string;
+    value: number;
+    window: string;
+}[];
+/**
+ * Creates log destinations config with Logtail token
+ */
+export declare const createLogDestinations: (logtailToken: Input<string>) => {
+    name: string;
+    logtail: {
+        token: Input<string>;
+    };
+}[];
+/**
+ * Default health check configuration
+ */
+export declare const defaultHealthCheck: {
+    httpPath: string;
+};

package/dist/helpers/discover-services.d.ts

@@ -0,0 +1,7 @@
+import type { ServiceConfig } from '../types';
+/**
+ * Auto-discovers all service configurations from a directory.
+ * Each .ts file (except index.ts) should export a ServiceConfig as default.
+ * @throws Error if duplicate ports are detected
+ */
+export declare function discoverServices(servicesDir: string): ServiceConfig[];

package/dist/helpers/docker-hub-image.d.ts

@@ -0,0 +1,14 @@
+import { type ImageConfig } from '../types';
+/**
+ * Helper to create a Docker Hub image config.
+ * For official images, use 'library' as the registry.
+ *
+ * @example
+ * // Official image: library/nats:2.10-alpine
+ * dockerHubImage('nats', '2.10-alpine')
+ *
+ * @example
+ * // User image: bitnami/redis:7.0
+ * dockerHubImage('redis', '7.0', 'bitnami')
+ */
+export declare const dockerHubImage: (repository: string, tag: string, registry?: string) => ImageConfig;

package/dist/helpers/image.d.ts

@@ -0,0 +1,13 @@
+import type { Output } from '@pulumi/pulumi';
+/**
+ * Gets the image configuration for a given repository.
+ * @param repository - The name of the repository.
+ * @returns The image configuration.
+ */
+export declare const getImage: (repository: string, registryCredentials: Output<string>) => {
+    registryType: any;
+    registry: string;
+    repository: string;
+    registryCredentials: Output<string>;
+    tag: string;
+};

package/dist/helpers/index.d.ts

@@ -0,0 +1,7 @@
+export * from './config';
+export * from './discover-services';
+export * from './docker-hub-image';
+export * from './image';
+export * from './service-builder';
+export * from './service-runtime';
+export * from './service-urls';

package/dist/helpers/service-builder.d.ts

@@ -0,0 +1,27 @@
+import type { AppSpecService } from '@pulumi/digitalocean/types/input';
+import type { Output } from '@pulumi/pulumi';
+import type { ServiceConfig } from '../types';
+export interface BuildServicesOptions {
+    serviceConfigs: ServiceConfig[];
+    registryCredentials: Output<string>;
+    logtailToken: Output<string>;
+}
+/**
+ * Builds the services array from service configs.
+ */
+export declare function buildServices(options: BuildServicesOptions): AppSpecService[];
+/**
+ * Builds the ingress rules from service configs.
+ * Only includes services that have both an ingressPrefix AND httpPort defined.
+ * Services with only internalPorts cannot have ingress rules.
+ */
+export declare function buildIngressRules(serviceConfigs: ServiceConfig[]): {
+    component: {
+        name: (import("@pulumi/pulumi").Input<string> | undefined) & string;
+    };
+    match: {
+        path: {
+            prefix: string;
+        };
+    };
+}[];

package/dist/helpers/service-runtime.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Runtime helpers for services to access their configuration.
+ * These functions read from environment variables set by generate-env (local)
+ * or injected by DO App Platform (production).
+ */
+import type { ServiceName } from '../types';
+/**
+ * Get the port for a service from environment variables.
+ * Reads from <SERVICE_NAME>_PORT (e.g., ORDERS_PORT, API_GATEWAY_PORT)
+ *
+ * @param serviceName - The service name (e.g., 'orders', 'api-gateway')
+ * @param defaultPort - Fallback port if env var is not set (default: 8080)
+ * @returns The configured port number
+ *
+ * @example
+ * ```typescript
+ * import { getServicePort } from '@crossdelta/infrastructure/env'
+ *
+ * const port = getServicePort('orders', 3001)
+ * // Reads process.env.ORDERS_PORT, falls back to 3001
+ * ```
+ */
+export declare function getServicePort(serviceName: ServiceName, defaultPort?: number): number;
+/**
+ * Get the URL for a service from environment variables.
+ * Reads from <SERVICE_NAME>_URL (e.g., ORDERS_URL, API_GATEWAY_URL)
+ *
+ * @param serviceName - The service name (e.g., 'orders', 'api-gateway')
+ * @returns The service URL or undefined if not set
+ *
+ * @example
+ * ```typescript
+ * import { getServiceUrl } from '@crossdelta/infrastructure/env'
+ *
+ * const ordersUrl = getServiceUrl('orders')
+ * // Returns process.env.ORDERS_URL
+ * ```
+ */
+export declare function getServiceUrl(serviceName: ServiceName): string | undefined;

package/dist/helpers/service-urls.d.ts

@@ -0,0 +1,27 @@
+import type { AppSpecEnv } from '@pulumi/digitalocean/types/input';
+import type { ServiceConfig } from '../types';
+/**
+ * Generate internal service URLs for service-to-service communication.
+ * Uses DigitalOcean App Platform's internal DNS (e.g., http://orders:3001)
+ * Uses internalUrl if defined, otherwise defaults to http://{name}:{port}
+ */
+export declare function buildInternalUrls(serviceConfigs: ServiceConfig[]): Record<string, string>;
+/**
+ * Generate external service URLs based on primary domain and ingress prefix.
+ */
+export declare function buildExternalUrls(serviceConfigs: ServiceConfig[], baseUrl: string): Record<string, string>;
+/**
+ * Generate local development URLs (localhost with configured ports).
+ */
+export declare function buildLocalUrls(serviceConfigs: ServiceConfig[]): Record<string, string>;
+/**
+ * Generate environment variables for service URLs.
+ * Used to inject service URLs into DO App Platform.
+ * Uses internalUrl if defined, otherwise defaults to http://{name}:{port}
+ */
+export declare function buildServiceUrlEnvs(serviceConfigs: ServiceConfig[]): AppSpecEnv[];
+/**
+ * Generate environment variables for service ports.
+ * Used to inject service ports into DO App Platform.
+ */
+export declare function buildServicePortEnvs(serviceConfigs: ServiceConfig[]): AppSpecEnv[];