@crossdelta/infrastructure 0.1.35

package/dist/index.cjs

@@ -0,0 +1,260 @@
+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/index.ts
+var exports_lib = {};
+__export(exports_lib, {
+  getServiceUrl: () => getServiceUrl,
+  getServicePort: () => getServicePort2,
+  getImage: () => getImage,
+  ensureDot: () => ensureDot,
+  dockerHubImage: () => dockerHubImage,
+  discoverServices: () => discoverServices,
+  defaultHealthCheck: () => defaultHealthCheck,
+  defaultAlerts: () => defaultAlerts,
+  createLogDestinations: () => createLogDestinations,
+  buildServices: () => buildServices,
+  buildServiceUrlEnvs: () => buildServiceUrlEnvs,
+  buildServicePortEnvs: () => buildServicePortEnvs,
+  buildLocalUrls: () => buildLocalUrls,
+  buildInternalUrls: () => buildInternalUrls,
+  buildIngressRules: () => buildIngressRules,
+  buildExternalUrls: () => buildExternalUrls,
+  RegistryType: () => RegistryType
+});
+module.exports = __toCommonJS(exports_lib);
+
+// lib/helpers/config.ts
+var ensureDot = (str) => {
+  return str.endsWith(".") ? str : `${str}.`;
+};
+var defaultAlerts = [
+  {
+    rule: "CPU_UTILIZATION",
+    operator: "GREATER_THAN",
+    value: 70,
+    window: "FIVE_MINUTES"
+  },
+  {
+    rule: "MEM_UTILIZATION",
+    operator: "GREATER_THAN",
+    value: 70,
+    window: "FIVE_MINUTES"
+  }
+];
+var createLogDestinations = (logtailToken) => [
+  {
+    name: "better-stacks-logs",
+    logtail: {
+      token: logtailToken
+    }
+  }
+];
+var defaultHealthCheck = {
+  httpPath: "/health"
+};
+// lib/helpers/discover-services.ts
+var import_node_fs = require("node:fs");
+var import_node_path = require("node:path");
+function getServicePort(config) {
+  if (config.httpPort)
+    return config.httpPort;
+  const internalPorts = config.internalPorts;
+  if (internalPorts?.[0])
+    return internalPorts[0];
+  return 8080;
+}
+function validateNoDuplicatePorts(configs) {
+  const portMap = new Map;
+  for (const config of configs) {
+    const port = getServicePort(config);
+    const existing = portMap.get(port) || [];
+    existing.push(config.name);
+    portMap.set(port, existing);
+  }
+  const conflicts = [...portMap.entries()].filter(([, services]) => services.length > 1).map(([port, services]) => `Port ${port}: ${services.join(", ")}`);
+  if (conflicts.length > 0) {
+    throw new Error(`Port conflicts detected:
+${conflicts.join(`
+`)}`);
+  }
+}
+function discoverServices(servicesDir) {
+  const files = import_node_fs.readdirSync(servicesDir).filter((file) => file.endsWith(".ts") && file !== "index.ts");
+  const configs = files.map((file) => {
+    const module2 = require(import_node_path.join(servicesDir, file));
+    return module2.default;
+  });
+  validateNoDuplicatePorts(configs);
+  return configs;
+}
+// lib/types/index.ts
+var RegistryType = {
+  DOCKER_HUB: "DOCKER_HUB",
+  GHCR: "GHCR",
+  DOCR: "DOCR"
+};
+
+// lib/helpers/docker-hub-image.ts
+var dockerHubImage = (repository, tag, registry = "library") => ({
+  registryType: RegistryType.DOCKER_HUB,
+  registry,
+  repository,
+  tag
+});
+// lib/helpers/image.ts
+var scopeImageTagsRaw = process.env.SCOPE_IMAGE_TAGS ?? "";
+var scopeImageTags = (() => {
+  if (!scopeImageTagsRaw.trim()) {
+    return {};
+  }
+  try {
+    const parsed = JSON.parse(scopeImageTagsRaw);
+    const tags = {};
+    for (const [key, value] of Object.entries(parsed ?? {})) {
+      if (typeof value === "string" && value.trim().length > 0) {
+        tags[key] = value.trim();
+      }
+    }
+    return tags;
+  } catch (error) {
+    console.warn("Unable to parse scope image tags from environment:", error);
+    return {};
+  }
+})();
+var resolveImageTag = (scopeName) => {
+  const tag = scopeImageTags[scopeName];
+  if (!tag) {
+    console.warn(`No image tag for "${scopeName}", using "latest" as fallback`);
+    return "latest";
+  }
+  return tag;
+};
+var getImage = (repository, registryCredentials) => {
+  const scopeName = repository.split("/").pop();
+  if (!scopeName) {
+    throw new Error(`Invalid repository name: ${repository}`);
+  }
+  return {
+    registryType: "GHCR",
+    registry: "orderboss",
+    repository,
+    registryCredentials,
+    tag: resolveImageTag(scopeName)
+  };
+};
+// lib/helpers/service-builder.ts
+function buildServices(options) {
+  const { serviceConfigs, registryCredentials, logtailToken } = options;
+  const logDestinations = createLogDestinations(logtailToken);
+  return serviceConfigs.map((config) => {
+    const {
+      ingressPrefix: _ingressPrefix,
+      skip: _skip,
+      image: configImage,
+      internalUrl: _internalUrl,
+      ...serviceConfig
+    } = config;
+    const image = configImage ?? getImage(`platform/${config.name}`, registryCredentials);
+    return {
+      healthCheck: defaultHealthCheck,
+      alerts: defaultAlerts,
+      logDestinations,
+      ...serviceConfig,
+      image
+    };
+  });
+}
+function buildIngressRules(serviceConfigs) {
+  return serviceConfigs.filter((config) => config.ingressPrefix !== undefined && config.httpPort !== undefined).map((config) => ({
+    component: { name: config.name },
+    match: {
+      path: {
+        prefix: config.ingressPrefix
+      }
+    }
+  }));
+}
+// lib/helpers/service-runtime.ts
+var toEnvKey = (name) => name.toUpperCase().replace(/-/g, "_");
+function getServicePort2(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];
+}
+// lib/helpers/service-urls.ts
+function getServicePort3(config) {
+  if (config.httpPort)
+    return config.httpPort;
+  const internalPorts = config.internalPorts;
+  if (internalPorts?.[0])
+    return internalPorts[0];
+  return 8080;
+}
+function buildInternalUrls(serviceConfigs) {
+  return Object.fromEntries(serviceConfigs.map((config) => {
+    const url = config.internalUrl ?? `http://${config.name}:${getServicePort3(config)}`;
+    return [config.name, url];
+  }));
+}
+function buildExternalUrls(serviceConfigs, baseUrl) {
+  return Object.fromEntries(serviceConfigs.filter((config) => config.ingressPrefix !== undefined).map((config) => {
+    const path = config.ingressPrefix === "/" ? "" : config.ingressPrefix;
+    return [config.name, `${baseUrl}${path}`];
+  }));
+}
+function buildLocalUrls(serviceConfigs) {
+  return Object.fromEntries(serviceConfigs.map((config) => {
+    const port = getServicePort3(config);
+    return [config.name, `http://localhost:${port}`];
+  }));
+}
+function buildServiceUrlEnvs(serviceConfigs) {
+  return serviceConfigs.map((config) => ({
+    key: `${config.name.toUpperCase().replace(/-/g, "_")}_URL`,
+    scope: "RUN_TIME",
+    value: config.internalUrl ?? `http://${config.name}:${getServicePort3(config)}`
+  }));
+}
+function buildServicePortEnvs(serviceConfigs) {
+  return serviceConfigs.map((config) => ({
+    key: `${config.name.toUpperCase().replace(/-/g, "_")}_PORT`,
+    scope: "RUN_TIME",
+    value: String(getServicePort3(config))
+  }));
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export * from './helpers';
+export * from './types';

package/dist/index.js

@@ -0,0 +1,231 @@
+import { createRequire } from "node:module";
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// lib/helpers/config.ts
+var ensureDot = (str) => {
+  return str.endsWith(".") ? str : `${str}.`;
+};
+var defaultAlerts = [
+  {
+    rule: "CPU_UTILIZATION",
+    operator: "GREATER_THAN",
+    value: 70,
+    window: "FIVE_MINUTES"
+  },
+  {
+    rule: "MEM_UTILIZATION",
+    operator: "GREATER_THAN",
+    value: 70,
+    window: "FIVE_MINUTES"
+  }
+];
+var createLogDestinations = (logtailToken) => [
+  {
+    name: "better-stacks-logs",
+    logtail: {
+      token: logtailToken
+    }
+  }
+];
+var defaultHealthCheck = {
+  httpPath: "/health"
+};
+// lib/helpers/discover-services.ts
+import { readdirSync } from "node:fs";
+import { join } from "node:path";
+function getServicePort(config) {
+  if (config.httpPort)
+    return config.httpPort;
+  const internalPorts = config.internalPorts;
+  if (internalPorts?.[0])
+    return internalPorts[0];
+  return 8080;
+}
+function validateNoDuplicatePorts(configs) {
+  const portMap = new Map;
+  for (const config of configs) {
+    const port = getServicePort(config);
+    const existing = portMap.get(port) || [];
+    existing.push(config.name);
+    portMap.set(port, existing);
+  }
+  const conflicts = [...portMap.entries()].filter(([, services]) => services.length > 1).map(([port, services]) => `Port ${port}: ${services.join(", ")}`);
+  if (conflicts.length > 0) {
+    throw new Error(`Port conflicts detected:
+${conflicts.join(`
+`)}`);
+  }
+}
+function discoverServices(servicesDir) {
+  const files = readdirSync(servicesDir).filter((file) => file.endsWith(".ts") && file !== "index.ts");
+  const configs = files.map((file) => {
+    const module = __require(join(servicesDir, file));
+    return module.default;
+  });
+  validateNoDuplicatePorts(configs);
+  return configs;
+}
+// lib/types/index.ts
+var RegistryType = {
+  DOCKER_HUB: "DOCKER_HUB",
+  GHCR: "GHCR",
+  DOCR: "DOCR"
+};
+
+// lib/helpers/docker-hub-image.ts
+var dockerHubImage = (repository, tag, registry = "library") => ({
+  registryType: RegistryType.DOCKER_HUB,
+  registry,
+  repository,
+  tag
+});
+// lib/helpers/image.ts
+var scopeImageTagsRaw = process.env.SCOPE_IMAGE_TAGS ?? "";
+var scopeImageTags = (() => {
+  if (!scopeImageTagsRaw.trim()) {
+    return {};
+  }
+  try {
+    const parsed = JSON.parse(scopeImageTagsRaw);
+    const tags = {};
+    for (const [key, value] of Object.entries(parsed ?? {})) {
+      if (typeof value === "string" && value.trim().length > 0) {
+        tags[key] = value.trim();
+      }
+    }
+    return tags;
+  } catch (error) {
+    console.warn("Unable to parse scope image tags from environment:", error);
+    return {};
+  }
+})();
+var resolveImageTag = (scopeName) => {
+  const tag = scopeImageTags[scopeName];
+  if (!tag) {
+    console.warn(`No image tag for "${scopeName}", using "latest" as fallback`);
+    return "latest";
+  }
+  return tag;
+};
+var getImage = (repository, registryCredentials) => {
+  const scopeName = repository.split("/").pop();
+  if (!scopeName) {
+    throw new Error(`Invalid repository name: ${repository}`);
+  }
+  return {
+    registryType: "GHCR",
+    registry: "orderboss",
+    repository,
+    registryCredentials,
+    tag: resolveImageTag(scopeName)
+  };
+};
+// lib/helpers/service-builder.ts
+function buildServices(options) {
+  const { serviceConfigs, registryCredentials, logtailToken } = options;
+  const logDestinations = createLogDestinations(logtailToken);
+  return serviceConfigs.map((config) => {
+    const {
+      ingressPrefix: _ingressPrefix,
+      skip: _skip,
+      image: configImage,
+      internalUrl: _internalUrl,
+      ...serviceConfig
+    } = config;
+    const image = configImage ?? getImage(`platform/${config.name}`, registryCredentials);
+    return {
+      healthCheck: defaultHealthCheck,
+      alerts: defaultAlerts,
+      logDestinations,
+      ...serviceConfig,
+      image
+    };
+  });
+}
+function buildIngressRules(serviceConfigs) {
+  return serviceConfigs.filter((config) => config.ingressPrefix !== undefined && config.httpPort !== undefined).map((config) => ({
+    component: { name: config.name },
+    match: {
+      path: {
+        prefix: config.ingressPrefix
+      }
+    }
+  }));
+}
+// lib/helpers/service-runtime.ts
+var toEnvKey = (name) => name.toUpperCase().replace(/-/g, "_");
+function getServicePort2(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];
+}
+// lib/helpers/service-urls.ts
+function getServicePort3(config) {
+  if (config.httpPort)
+    return config.httpPort;
+  const internalPorts = config.internalPorts;
+  if (internalPorts?.[0])
+    return internalPorts[0];
+  return 8080;
+}
+function buildInternalUrls(serviceConfigs) {
+  return Object.fromEntries(serviceConfigs.map((config) => {
+    const url = config.internalUrl ?? `http://${config.name}:${getServicePort3(config)}`;
+    return [config.name, url];
+  }));
+}
+function buildExternalUrls(serviceConfigs, baseUrl) {
+  return Object.fromEntries(serviceConfigs.filter((config) => config.ingressPrefix !== undefined).map((config) => {
+    const path = config.ingressPrefix === "/" ? "" : config.ingressPrefix;
+    return [config.name, `${baseUrl}${path}`];
+  }));
+}
+function buildLocalUrls(serviceConfigs) {
+  return Object.fromEntries(serviceConfigs.map((config) => {
+    const port = getServicePort3(config);
+    return [config.name, `http://localhost:${port}`];
+  }));
+}
+function buildServiceUrlEnvs(serviceConfigs) {
+  return serviceConfigs.map((config) => ({
+    key: `${config.name.toUpperCase().replace(/-/g, "_")}_URL`,
+    scope: "RUN_TIME",
+    value: config.internalUrl ?? `http://${config.name}:${getServicePort3(config)}`
+  }));
+}
+function buildServicePortEnvs(serviceConfigs) {
+  return serviceConfigs.map((config) => ({
+    key: `${config.name.toUpperCase().replace(/-/g, "_")}_PORT`,
+    scope: "RUN_TIME",
+    value: String(getServicePort3(config))
+  }));
+}
+export {
+  getServiceUrl,
+  getServicePort2 as getServicePort,
+  getImage,
+  ensureDot,
+  dockerHubImage,
+  discoverServices,
+  defaultHealthCheck,
+  defaultAlerts,
+  createLogDestinations,
+  buildServices,
+  buildServiceUrlEnvs,
+  buildServicePortEnvs,
+  buildLocalUrls,
+  buildInternalUrls,
+  buildIngressRules,
+  buildExternalUrls,
+  RegistryType
+};

package/dist/types/index.d.ts

@@ -0,0 +1,81 @@
+import type { AppSpecService } from '@pulumi/digitalocean/types/input';
+/**
+ * Supported container registry types for DigitalOcean App Platform.
+ */
+export declare const RegistryType: {
+    /** Docker Hub - public or private images */
+    readonly DOCKER_HUB: "DOCKER_HUB";
+    /** GitHub Container Registry */
+    readonly GHCR: "GHCR";
+    /** DigitalOcean Container Registry */
+    readonly DOCR: "DOCR";
+};
+export type RegistryType = (typeof RegistryType)[keyof typeof RegistryType];
+/**
+ * Image configuration for a service.
+ */
+export interface ImageConfig {
+    /** Registry type */
+    registryType: RegistryType;
+    /** Registry name (e.g., 'library' for official Docker Hub images, 'orderboss' for GHCR) */
+    registry: string;
+    /** Repository name (e.g., 'nats', 'platform/storefront') */
+    repository: string;
+    /** Image tag (e.g., '2.10-alpine', 'latest') */
+    tag: string;
+}
+/**
+ * Configuration for a service that will be deployed to DigitalOcean App Platform.
+ * Each service in infra/services/*.ts should export a default object of this type.
+ *
+ * ## Port Configuration
+ *
+ * Services can expose ports in two ways:
+ *
+ * - `httpPort`: Public HTTP port with ingress routing (requires `ingressPrefix`)
+ * - `internalPorts`: Internal-only ports, not publicly accessible
+ *
+ * The **first port** (httpPort or internalPorts[0]) is used as the primary port for:
+ * - `<SERVICE>_PORT` environment variable
+ * - `<SERVICE>_URL` environment variable (unless `internalUrl` is set)
+ *
+ * ## Examples
+ *
+ * ```ts
+ * // Public service (API Gateway)
+ * { httpPort: 4000, ingressPrefix: '/api' }
+ *
+ * // Internal-only service (Orders)
+ * { internalPorts: [4001] }
+ *
+ * // Internal service with custom protocol (NATS)
+ * { internalPorts: [4222, 8222], internalUrl: 'nats://nats:4222' }
+ * ```
+ *
+ * @see https://docs.digitalocean.com/reference/api/digitalocean/#tag/Apps
+ */
+export type ServiceConfig = Partial<Omit<AppSpecService, 'image'>> & {
+    /** Unique name of the service (required) */
+    name: string;
+    /**
+     * Ingress path prefix for public routing (e.g., '/api').
+     * Only used when `httpPort` is set. Services with only `internalPorts` cannot have ingress.
+     */
+    ingressPrefix?: string;
+    /** Set to true to exclude this service from deployment */
+    skip?: boolean;
+    /** Custom image configuration (defaults to GHCR image based on service name) */
+    image?: ImageConfig;
+    /**
+     * Override the internal URL for service-to-service communication.
+     * Use this for non-HTTP protocols (e.g., 'nats://nats:4222').
+     * If not set, defaults to `http://{name}:{primaryPort}`.
+     */
+    internalUrl?: string;
+};
+/**
+ * Full service spec after merging with common config.
+ * This is what gets passed to the DigitalOcean App spec.
+ */
+export type FullServiceSpec = AppSpecService;
+export * from './service-names';

package/dist/types/service-names.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Auto-generated file - do not edit manually!
+ * Generated by: bun run generate-env
+ */
+/**
+ * Known service names in the platform.
+ * This type is auto-generated from infra/services/*.ts
+ */
+export type ServiceName = 'nats' | 'orders' | 'storefront' | 'api-gateway';

package/lib/env.ts

@@ -0,0 +1,10 @@
+/**
+ * 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/lib/helpers/config.ts

@@ -0,0 +1,45 @@
+import type { Input } from '@pulumi/pulumi'
+
+/**
+ * Ensures that a string ends with a dot (useful for DNS CNAME values).
+ */
+export const ensureDot = (str: string) => {
+  return str.endsWith('.') ? str : `${str}.`
+}
+
+/**
+ * Common alert configuration for services
+ */
+export const defaultAlerts = [
+  {
+    rule: 'CPU_UTILIZATION',
+    operator: 'GREATER_THAN',
+    value: 70,
+    window: 'FIVE_MINUTES',
+  },
+  {
+    rule: 'MEM_UTILIZATION',
+    operator: 'GREATER_THAN',
+    value: 70,
+    window: 'FIVE_MINUTES',
+  },
+]
+
+/**
+ * Creates log destinations config with Logtail token
+ */
+export const createLogDestinations = (logtailToken: Input<string>) => [
+  {
+    name: 'better-stacks-logs',
+    logtail: {
+      token: logtailToken,
+    },
+  },
+]
+
+/**
+ * Default health check configuration
+ */
+export const defaultHealthCheck = {
+  httpPath: '/health',
+}

package/lib/helpers/discover-services.ts

@@ -0,0 +1,57 @@
+import { readdirSync } from 'node:fs'
+import { join } from 'node:path'
+import type { ServiceConfig } from '../types'
+
+/**
+ * Get the primary port for a service (for validation).
+ * Prefers httpPort, falls back to first internalPort, then 8080.
+ */
+function getServicePort(config: ServiceConfig): number {
+  if (config.httpPort) return config.httpPort as number
+  const internalPorts = config.internalPorts as number[] | undefined
+  if (internalPorts?.[0]) return internalPorts[0]
+  return 8080
+}
+
+/**
+ * Validates that no two services use the same port.
+ * @throws Error if duplicate ports are found
+ */
+function validateNoDuplicatePorts(configs: ServiceConfig[]): void {
+  const portMap = new Map<number, string[]>()
+
+  for (const config of configs) {
+    const port = getServicePort(config)
+    const existing = portMap.get(port) || []
+    existing.push(config.name)
+    portMap.set(port, existing)
+  }
+
+  const conflicts = [...portMap.entries()]
+    .filter(([, services]) => services.length > 1)
+    .map(([port, services]) => `Port ${port}: ${services.join(', ')}`)
+
+  if (conflicts.length > 0) {
+    throw new Error(`Port conflicts detected:\n${conflicts.join('\n')}`)
+  }
+}
+
+/**
+ * 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 function discoverServices(servicesDir: string): ServiceConfig[] {
+  const files = readdirSync(servicesDir).filter(
+    (file) => file.endsWith('.ts') && file !== 'index.ts'
+  )
+
+  const configs = files.map((file) => {
+    const module = require(join(servicesDir, file))
+    return module.default as ServiceConfig
+  })
+
+  validateNoDuplicatePorts(configs)
+
+  return configs
+}