@geekmidas/cli 0.54.0 → 1.0.0

package/dist/{workspace-CaVW6j2q.cjs → workspace-BFRUOOrh.cjs}

@@ -1698,6 +1698,60 @@ const $ZodUnion = /* @__PURE__ */ $constructor("$ZodUnion", (inst, def) => {
 		});
 	};
 });
+const $ZodDiscriminatedUnion = /* @__PURE__ */ $constructor("$ZodDiscriminatedUnion", (inst, def) => {
+	$ZodUnion.init(inst, def);
+	const _super = inst._zod.parse;
+	defineLazy(inst._zod, "propValues", () => {
+		const propValues = {};
+		for (const option of def.options) {
+			const pv = option._zod.propValues;
+			if (!pv || Object.keys(pv).length === 0) throw new Error(`Invalid discriminated union option at index "${def.options.indexOf(option)}"`);
+			for (const [k, v] of Object.entries(pv)) {
+				if (!propValues[k]) propValues[k] = /* @__PURE__ */ new Set();
+				for (const val of v) propValues[k].add(val);
+			}
+		}
+		return propValues;
+	});
+	const disc = cached(() => {
+		const opts = def.options;
+		const map = /* @__PURE__ */ new Map();
+		for (const o of opts) {
+			const values = o._zod.propValues?.[def.discriminator];
+			if (!values || values.size === 0) throw new Error(`Invalid discriminated union option at index "${def.options.indexOf(o)}"`);
+			for (const v of values) {
+				if (map.has(v)) throw new Error(`Duplicate discriminator value "${String(v)}"`);
+				map.set(v, o);
+			}
+		}
+		return map;
+	});
+	inst._zod.parse = (payload, ctx) => {
+		const input = payload.value;
+		if (!isObject(input)) {
+			payload.issues.push({
+				code: "invalid_type",
+				expected: "object",
+				input,
+				inst
+			});
+			return payload;
+		}
+		const opt = disc.value.get(input?.[def.discriminator]);
+		if (opt) return opt._zod.run(payload, ctx);
+		if (def.unionFallback) return _super(payload, ctx);
+		payload.issues.push({
+			code: "invalid_union",
+			errors: [],
+			note: "No matching discriminator",
+			discriminator: def.discriminator,
+			input,
+			path: [def.discriminator],
+			inst
+		});
+		return payload;
+	};
+});
 const $ZodIntersection = /* @__PURE__ */ $constructor("$ZodIntersection", (inst, def) => {
 	$ZodType.init(inst, def);
 	inst._zod.parse = (payload, ctx) => {
@@ -1882,6 +1936,24 @@ const $ZodEnum = /* @__PURE__ */ $constructor("$ZodEnum", (inst, def) => {
 		return payload;
 	};
 });
+const $ZodLiteral = /* @__PURE__ */ $constructor("$ZodLiteral", (inst, def) => {
+	$ZodType.init(inst, def);
+	if (def.values.length === 0) throw new Error("Cannot create literal schema with no valid values");
+	const values = new Set(def.values);
+	inst._zod.values = values;
+	inst._zod.pattern = new RegExp(`^(${def.values.map((o) => typeof o === "string" ? escapeRegex(o) : o ? escapeRegex(o.toString()) : String(o)).join("|")})$`);
+	inst._zod.parse = (payload, _ctx) => {
+		const input = payload.value;
+		if (values.has(input)) return payload;
+		payload.issues.push({
+			code: "invalid_value",
+			values: def.values,
+			input,
+			inst
+		});
+		return payload;
+	};
+});
 const $ZodTransform = /* @__PURE__ */ $constructor("$ZodTransform", (inst, def) => {
 	$ZodType.init(inst, def);
 	inst._zod.parse = (payload, ctx) => {
@@ -2564,6 +2636,17 @@ function _array(Class, element, params) {
 		...normalizeParams(params)
 	});
 }
+function _custom(Class, fn, _params) {
+	const norm = normalizeParams(_params);
+	norm.abort ?? (norm.abort = true);
+	const schema = new Class({
+		type: "custom",
+		check: "custom",
+		fn,
+		...norm
+	});
+	return schema;
+}
 function _refine(Class, fn, _params) {
 	const schema = new Class({
 		type: "custom",
@@ -3033,6 +3116,18 @@ function union(options, params) {
 		...normalizeParams(params)
 	});
 }
+const ZodDiscriminatedUnion = /* @__PURE__ */ $constructor("ZodDiscriminatedUnion", (inst, def) => {
+	ZodUnion.init(inst, def);
+	$ZodDiscriminatedUnion.init(inst, def);
+});
+function discriminatedUnion(discriminator, options, params) {
+	return new ZodDiscriminatedUnion({
+		type: "union",
+		options,
+		discriminator,
+		...normalizeParams(params)
+	});
+}
 const ZodIntersection = /* @__PURE__ */ $constructor("ZodIntersection", (inst, def) => {
 	$ZodIntersection.init(inst, def);
 	ZodType.init(inst, def);
@@ -3095,6 +3190,22 @@ function _enum(values, params) {
 		...normalizeParams(params)
 	});
 }
+const ZodLiteral = /* @__PURE__ */ $constructor("ZodLiteral", (inst, def) => {
+	$ZodLiteral.init(inst, def);
+	ZodType.init(inst, def);
+	inst.values = new Set(def.values);
+	Object.defineProperty(inst, "value", { get() {
+		if (def.values.length > 1) throw new Error("This schema contains multiple valid literal values. Use `.values` instead.");
+		return def.values[0];
+	} });
+});
+function literal(value, params) {
+	return new ZodLiteral({
+		type: "literal",
+		values: Array.isArray(value) ? value : [value],
+		...normalizeParams(params)
+	});
+}
 const ZodTransform = /* @__PURE__ */ $constructor("ZodTransform", (inst, def) => {
 	$ZodTransform.init(inst, def);
 	ZodType.init(inst, def);
@@ -3230,6 +3341,9 @@ const ZodCustom = /* @__PURE__ */ $constructor("ZodCustom", (inst, def) => {
 	$ZodCustom.init(inst, def);
 	ZodType.init(inst, def);
 });
+function custom(fn, _params) {
+	return _custom(ZodCustom, fn ?? (() => true), _params);
+}
 function refine(fn, _params = {}) {
 	return _refine(ZodCustom, fn, _params);
 }
@@ -3239,26 +3353,6 @@ function superRefine(fn) {
 const describe = describe$1;
 const meta = meta$1;
 
-//#endregion
-//#region ../../node_modules/.pnpm/zod@4.1.13/node_modules/zod/v4/classic/compat.js
-/** @deprecated Use the raw string literal codes instead, e.g. "invalid_type". */
-const ZodIssueCode = {
-	invalid_type: "invalid_type",
-	too_big: "too_big",
-	too_small: "too_small",
-	invalid_format: "invalid_format",
-	not_multiple_of: "not_multiple_of",
-	unrecognized_keys: "unrecognized_keys",
-	invalid_union: "invalid_union",
-	invalid_key: "invalid_key",
-	invalid_element: "invalid_element",
-	invalid_value: "invalid_value",
-	custom: "custom"
-};
-/** @deprecated Do not use. Stub definition, only included for zod-to-json-schema compatibility. */
-var ZodFirstPartyTypeKind;
-(function(ZodFirstPartyTypeKind$1) {})(ZodFirstPartyTypeKind || (ZodFirstPartyTypeKind = {}));
-
 //#endregion
 //#region src/workspace/schema.ts
 /**
@@ -3402,11 +3496,167 @@ const DokployWorkspaceConfigSchema = object({
 	registryId: string().optional()
 });
 /**
+* Valid AWS regions.
+*/
+const AwsRegionSchema = _enum([
+	"us-east-1",
+	"us-east-2",
+	"us-west-1",
+	"us-west-2",
+	"af-south-1",
+	"ap-east-1",
+	"ap-south-1",
+	"ap-south-2",
+	"ap-southeast-1",
+	"ap-southeast-2",
+	"ap-southeast-3",
+	"ap-southeast-4",
+	"ap-northeast-1",
+	"ap-northeast-2",
+	"ap-northeast-3",
+	"ca-central-1",
+	"eu-central-1",
+	"eu-central-2",
+	"eu-west-1",
+	"eu-west-2",
+	"eu-west-3",
+	"eu-south-1",
+	"eu-south-2",
+	"eu-north-1",
+	"me-south-1",
+	"me-central-1",
+	"sa-east-1"
+]);
+/**
+* DNS record types supported across providers.
+*/
+const DnsRecordTypeSchema = _enum([
+	"A",
+	"AAAA",
+	"CNAME",
+	"MX",
+	"TXT",
+	"NS",
+	"SRV",
+	"CAA"
+]);
+/**
+* A DNS record as returned by the provider.
+*/
+const DnsRecordSchema = object({
+	name: string(),
+	type: DnsRecordTypeSchema,
+	ttl: number().int().positive(),
+	values: array(string())
+});
+/**
+* A DNS record to create or update.
+*/
+const UpsertDnsRecordSchema = object({
+	name: string(),
+	type: DnsRecordTypeSchema,
+	ttl: number().int().positive(),
+	value: string()
+});
+/**
+* Result of an upsert operation.
+*/
+const UpsertResultSchema = object({
+	record: UpsertDnsRecordSchema,
+	created: boolean(),
+	unchanged: boolean()
+});
+/**
+* Hostinger DNS provider config (without domain - domain is the record key).
+*/
+const HostingerDnsProviderSchema = object({
+	provider: literal("hostinger"),
+	ttl: number().int().positive().optional()
+});
+/**
+* Route53 DNS provider config (without domain - domain is the record key).
+*/
+const Route53DnsProviderSchema = object({
+	provider: literal("route53"),
+	region: AwsRegionSchema.optional(),
+	profile: string().optional(),
+	hostedZoneId: string().optional(),
+	ttl: number().int().positive().optional()
+});
+/**
+* Cloudflare DNS provider config (placeholder for future).
+*/
+const CloudflareDnsProviderSchema = object({
+	provider: literal("cloudflare"),
+	ttl: number().int().positive().optional()
+});
+/**
+* Manual DNS configuration (user handles DNS themselves).
+*/
+const ManualDnsProviderSchema = object({ provider: literal("manual") });
+/**
+* Custom DNS provider config (user-provided implementation).
+*/
+const CustomDnsProviderSchema = object({
+	provider: custom((val) => typeof val === "object" && val !== null && typeof val.name === "string" && typeof val.getRecords === "function" && typeof val.upsertRecords === "function", { message: "Custom DNS provider must implement name, getRecords(), and upsertRecords() methods" }),
+	ttl: number().int().positive().optional()
+});
+/**
+* Built-in DNS provider config (discriminated union).
+*/
+const BuiltInDnsProviderSchema = discriminatedUnion("provider", [
+	HostingerDnsProviderSchema,
+	Route53DnsProviderSchema,
+	CloudflareDnsProviderSchema,
+	ManualDnsProviderSchema
+]);
+/**
+* Single DNS provider config (for one domain).
+*/
+const DnsProviderSchema = union([BuiltInDnsProviderSchema, CustomDnsProviderSchema]);
+/**
+* DNS configuration schema.
+*
+* Maps root domains to their DNS provider configuration.
+* Example:
+* ```
+* dns: {
+*   'geekmidas.dev': { provider: 'hostinger' },
+*   'geekmidas.com': { provider: 'route53' },
+* }
+* ```
+*
+* Supported providers:
+* - 'hostinger': Use Hostinger DNS API
+* - 'route53': Use AWS Route53
+* - 'cloudflare': Use Cloudflare DNS API (future)
+* - 'manual': Don't create records, just print required records
+* - Custom: Provide a DnsProvider implementation
+*/
+const DnsConfigSchema = record(string(), DnsProviderSchema);
+const HostingerDnsConfigSchema = HostingerDnsProviderSchema.extend({ domain: string().min(1, "Domain is required") });
+const Route53DnsConfigSchema = Route53DnsProviderSchema.extend({ domain: string().min(1, "Domain is required") });
+const CloudflareDnsConfigSchema = CloudflareDnsProviderSchema.extend({ domain: string().min(1, "Domain is required") });
+const ManualDnsConfigSchema = ManualDnsProviderSchema.extend({ domain: string().min(1, "Domain is required") });
+const CustomDnsConfigSchema = CustomDnsProviderSchema.extend({ domain: string().min(1, "Domain is required") });
+const BuiltInDnsConfigSchema = discriminatedUnion("provider", [
+	HostingerDnsConfigSchema,
+	Route53DnsConfigSchema,
+	CloudflareDnsConfigSchema,
+	ManualDnsConfigSchema
+]);
+const LegacyDnsConfigSchema = union([BuiltInDnsConfigSchema, CustomDnsConfigSchema]);
+/**
+* Combined DNS config that supports both new multi-domain and legacy single-domain formats.
+*/
+const DnsConfigWithLegacySchema = union([DnsConfigSchema, LegacyDnsConfigSchema]);
+/**
 * Deploy configuration schema.
 */
 const DeployConfigSchema = object({
 	default: DeployTargetSchema.optional(),
-	dokploy: DokployWorkspaceConfigSchema.optional()
+	dokploy: DokployWorkspaceConfigSchema.optional(),
+	dns: DnsConfigWithLegacySchema.optional()
 });
 /**
 * Models configuration schema.
@@ -3431,6 +3681,34 @@ const SecretsConfigSchema = object({
 	kdf: _enum(["scrypt", "pbkdf2"]).optional()
 });
 /**
+* Local state provider config.
+*/
+const LocalStateConfigSchema = object({ provider: literal("local") });
+/**
+* SSM state provider config (requires region).
+*/
+const SSMStateConfigSchema = object({
+	provider: literal("ssm"),
+	region: AwsRegionSchema
+});
+/**
+* Custom state provider config (user-provided implementation).
+*/
+const CustomStateConfigSchema = object({ provider: custom((val) => typeof val === "object" && val !== null && typeof val.read === "function" && typeof val.write === "function", { message: "Custom provider must implement read() and write() methods" }) });
+/**
+* Built-in state provider config (discriminated union).
+*/
+const BuiltInStateConfigSchema = discriminatedUnion("provider", [LocalStateConfigSchema, SSMStateConfigSchema]);
+/**
+* State configuration schema.
+*
+* Configures how deployment state is stored.
+* - 'local': Store in .gkm/deploy-{stage}.json (default)
+* - 'ssm': Store in AWS SSM Parameter Store (requires region)
+* - Custom: Provide a StateProvider implementation with read/write methods
+*/
+const StateConfigSchema = union([BuiltInStateConfigSchema, CustomStateConfigSchema]);
+/**
 * App configuration schema.
 */
 const AppConfigSchema = object({
@@ -3496,7 +3774,8 @@ const WorkspaceConfigSchema = object({
 	shared: SharedConfigSchema.optional(),
 	deploy: DeployConfigSchema.optional(),
 	services: ServicesConfigSchema.optional(),
-	secrets: SecretsConfigSchema.optional()
+	secrets: SecretsConfigSchema.optional(),
+	state: StateConfigSchema.optional()
 }).refine((data) => {
 	const appNames = Object.keys(data.apps);
 	for (const [appName, app] of Object.entries(data.apps)) for (const dep of app.dependencies ?? []) {
@@ -3528,7 +3807,7 @@ const WorkspaceConfigSchema = object({
 	const defaultTarget = data.deploy?.default;
 	if (defaultTarget && !isDeployTargetSupported(defaultTarget)) {
 		ctx.addIssue({
-			code: ZodIssueCode.custom,
+			code: "custom",
 			message: getDeployTargetError(defaultTarget),
 			path: ["deploy", "default"]
 		});
@@ -3536,7 +3815,7 @@ const WorkspaceConfigSchema = object({
 	}
 	for (const [appName, app] of Object.entries(data.apps)) if (app.deploy && !isDeployTargetSupported(app.deploy)) {
 		ctx.addIssue({
-			code: ZodIssueCode.custom,
+			code: "custom",
 			message: getDeployTargetError(app.deploy, appName),
 			path: [
 				"apps",
@@ -3546,6 +3825,11 @@ const WorkspaceConfigSchema = object({
 		});
 		return;
 	}
+	if (data.state?.provider === "ssm" && !data.name) ctx.addIssue({
+		code: "custom",
+		message: "Workspace name is required when using SSM state provider. Add \"name\" to your gkm.config.ts.",
+		path: ["name"]
+	});
 });
 /**
 * Validate workspace configuration.
@@ -3930,4 +4214,4 @@ Object.defineProperty(exports, 'wrapSingleAppAsWorkspace', {
     return wrapSingleAppAsWorkspace;
   }
 });
-//# sourceMappingURL=workspace-CaVW6j2q.cjs.map
+//# sourceMappingURL=workspace-BFRUOOrh.cjs.map