@ts-cloud/core 0.5.34 → 0.6.0

package/dist/deployment-mode.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Deployment-mode detection: the single source of truth for whether a project
+ * is a SERVER deployment (`infrastructure.compute` - an EC2/Fargate box) or a
+ * SERVERLESS deployment (`environments.<env>.app` - Lambda functions).
+ *
+ * The two are mutually exclusive: a project may not declare both a server and a
+ * serverless app. {@link detectDeploymentTargets} reports what is configured and
+ * {@link resolveDeploymentMode} picks the effective mode (honoring an explicit
+ * `config.mode`); {@link deploymentCoexistenceError} returns a message when both
+ * are configured so callers can abort with a clear contract.
+ */
+import type { CloudConfig, DeploymentMode } from './types';
+export interface DeploymentTargets {
+    /** A server box is configured (`infrastructure.compute`). */
+    server: boolean;
+    /** A serverless Lambda app is configured (`environments.<env>.app`). */
+    serverless: boolean;
+}
+/** What deployment targets the config declares. Pure and side-effect free. */
+export declare function detectDeploymentTargets(config: Pick<CloudConfig, 'infrastructure' | 'environments'>): DeploymentTargets;
+/**
+ * The effective deployment mode. An explicit `config.mode` wins (it pins the
+ * detection); otherwise a configured serverless app implies `serverless`, and a
+ * configured compute box (or nothing else) implies `server`. When both targets
+ * are configured this still returns a value, but {@link deploymentCoexistenceError}
+ * is non-null and callers should abort first.
+ */
+export declare function resolveDeploymentMode(config: Pick<CloudConfig, 'infrastructure' | 'environments' | 'mode'>): DeploymentMode;
+/**
+ * A human-readable error when a project declares BOTH a server and a serverless
+ * app (they cannot coexist), or when an explicit `config.mode` contradicts the
+ * configured resources. Returns null when the config is consistent.
+ */
+export declare function deploymentCoexistenceError(config: Pick<CloudConfig, 'infrastructure' | 'environments' | 'mode'>): string | null;

package/dist/index.d.ts

@@ -2,6 +2,7 @@
  * ts-cloud Core - CloudFormation Generator Engine
  */
 export * from './types';
+export * from './deployment-mode';
 export * from './drivers';
 export * from './template-builder';
 export { validateTemplate, validateTemplateSize, validateResourceLimits, type ValidationResult, } from './template-validator';

package/dist/index.js

@@ -1075,6 +1075,31 @@ var RealtimePresets = {
     }
   }
 };
+// src/deployment-mode.ts
+function detectDeploymentTargets(config) {
+  const server = config.infrastructure?.compute != null;
+  const serverless = Object.values(config.environments ?? {}).some((env) => env?.app != null);
+  return { server, serverless };
+}
+function resolveDeploymentMode(config) {
+  if (config.mode === "server" || config.mode === "serverless")
+    return config.mode;
+  const { serverless } = detectDeploymentTargets(config);
+  return serverless ? "serverless" : "server";
+}
+function deploymentCoexistenceError(config) {
+  const { server, serverless } = detectDeploymentTargets(config);
+  if (server && serverless) {
+    return "A project cannot be both a server and a serverless deployment. " + "Found `infrastructure.compute` (server) AND `environments.<env>.app` (serverless Lambda). " + "Keep one: remove `infrastructure.compute` for a serverless app, or remove `environments.<env>.app` for a server.";
+  }
+  if (config.mode === "server" && serverless && !server) {
+    return "Config sets `mode: 'server'` but declares a serverless app (`environments.<env>.app`). " + "Remove the app or change the mode.";
+  }
+  if (config.mode === "serverless" && server && !serverless) {
+    return "Config sets `mode: 'serverless'` but declares a server (`infrastructure.compute`). " + "Remove the compute block or change the mode.";
+  }
+  return null;
+}
 // src/drivers/types.ts
 function resolveCloudProvider(config) {
   if (config.cloud?.provider)
@@ -20694,7 +20719,7 @@ function createFullStackAppPreset(options) {
       slug,
       region: "us-east-1"
     },
-    mode: "hybrid",
+    mode: "server",
     environments: {
       production: {
         type: "production",
@@ -25165,9 +25190,8 @@ var cloud_config_schema_default = {
     },
     mode: {
       type: "string",
-      description: "Deployment mode",
-      enum: ["server", "serverless", "hybrid"],
-      default: "serverless"
+      description: "Deployment mode (server and serverless are mutually exclusive; auto-detected when omitted)",
+      enum: ["server", "serverless"]
     },
     environments: {
       type: "object",
@@ -25729,8 +25753,8 @@ function validateAgainstSchema(config) {
   if (config.project?.region && !validRegions.includes(config.project.region)) {
     errors.push(`Invalid region: ${config.project.region}. Must be one of: ${validRegions.join(", ")}`);
   }
-  if (config.mode && !["server", "serverless", "hybrid"].includes(config.mode)) {
-    errors.push("Invalid mode: must be one of server, serverless, or hybrid");
+  if (config.mode && !["server", "serverless"].includes(config.mode)) {
+    errors.push("Invalid mode: must be one of server or serverless");
   }
   return {
     valid: errors.length === 0,
@@ -47184,6 +47208,7 @@ export {
   resolveQueueNames,
   resolveProjectStackName,
   resolveManagementDashboardSite,
+  resolveDeploymentMode,
   resolveDeployBucketName,
   resolveDashboardDomain,
   resolveCredentials,
@@ -47323,6 +47348,8 @@ export {
   diffTemplates,
   detectServiceRegion,
   detectMisconfigurations,
+  detectDeploymentTargets,
+  deploymentCoexistenceError,
   defaultLocalConfig,
   databaseUserManager,
   crossRegionReferenceManager,

package/dist/types.d.ts

@@ -138,11 +138,13 @@ export interface ProjectConfig {
 }
 /**
  * Deployment mode (optional)
- * @deprecated Mode is now auto-detected from your infrastructure configuration.
- * Simply define the resources you need (functions, servers, storage, etc.) and
- * ts-cloud will deploy them accordingly. No need to specify a mode.
+ * A project deploys as EITHER a server (`infrastructure.compute` - an EC2/Fargate
+ * box, Forge-style) OR serverless (`environments.<env>.app` - Lambda functions,
+ * Vapor-style). The two are mutually exclusive and cannot coexist in one project;
+ * ts-cloud auto-detects the mode from your config. Setting `mode` explicitly is
+ * optional and only pins the auto-detection.
  */
-export type DeploymentMode = 'server' | 'serverless' | 'hybrid';
+export type DeploymentMode = 'server' | 'serverless';
 export type EnvironmentType = 'production' | 'staging' | 'development';
 export interface EnvironmentConfig {
     type: EnvironmentType;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ts-cloud/core",
-  "version": "0.5.34",
+  "version": "0.6.0",
   "type": "module",
   "description": "Core CloudFormation generation library for ts-cloud",
   "author": "Chris Breuer <chris@stacksjs.com>",
@@ -31,7 +31,7 @@
     "typecheck": "tsc --noEmit"
   },
   "dependencies": {
-    "@ts-cloud/aws-types": "0.5.34"
+    "@ts-cloud/aws-types": "0.6.0"
   },
   "devDependencies": {
     "typescript": "^5.9.3"