@geekmidas/cloud 10.0.0-alpha.12 → 10.0.0-alpha.13

package/src/sst/__tests__/function.spec.ts

@@ -0,0 +1,192 @@
+import { describe, expect, it } from 'vitest';
+import { App } from '../App';
+import { Cron } from '../aws/Cron';
+import { Function } from '../aws/Function';
+import { type GkmLinkable, ResourceType } from '../Linkable';
+
+/**
+ * A Lambda and a schedule as data: the args each hands SST (a recording stub
+ * in `test/sst-globals.ts`), and the env validation that fails before deploy.
+ */
+
+const app = new App({
+	name: 'shop',
+	stage: 'prod',
+	domain: 'shop.test',
+	hostedZoneId: 'Z1',
+	region: 'eu-west-1',
+});
+const stack = app.stack('jobs');
+const db: GkmLinkable = { _id: 'db', _type: ResourceType.Postgres };
+
+const argsOf = (component: unknown) =>
+	(component as { args: Record<string, unknown> }).args;
+
+describe('Function', () => {
+	it('defaults the runtime and logging, and links only what its variables need', () => {
+		const fn = new Function(stack, 'Reports', {
+			handler: 'reports.handler',
+			links: [db],
+			envVars: ['DB_URL'],
+			environment: { FEATURE: 'on' },
+		});
+
+		expect(fn._type).toBe(ResourceType.Function);
+		expect(argsOf(fn)).toMatchObject({
+			handler: 'reports.handler',
+			runtime: 'nodejs24.x',
+			logging: { format: 'json' },
+			link: [db],
+			environment: expect.objectContaining({
+				SERVICE_NAME: 'Reports',
+				STAGE: 'prod',
+				FEATURE: 'on',
+			}),
+		});
+		expect(fn.validate().valid).toBe(true);
+	});
+
+	it('keeps a runtime and logging it was given', () => {
+		const fn = new Function(stack, 'Legacy', {
+			handler: 'legacy.handler',
+			runtime: 'nodejs20.x',
+			logging: { format: 'text' },
+		});
+
+		expect(argsOf(fn)).toMatchObject({
+			runtime: 'nodejs20.x',
+			logging: { format: 'text' },
+			link: [],
+		});
+	});
+
+	it('fails the synth on a variable no link provides, unless told not to check', () => {
+		expect(
+			() =>
+				new Function(stack, 'Mailer', {
+					handler: 'mailer.handler',
+					envVars: ['SMTP_URL'],
+				}),
+		).toThrow(/SMTP_URL/);
+
+		const unchecked = new Function(stack, 'Mailer', {
+			handler: 'mailer.handler',
+			envVars: ['SMTP_URL'],
+			autoValidate: false,
+		});
+		expect(unchecked.validate()).toMatchObject({
+			valid: false,
+			invalidVars: ['SMTP_URL'],
+		});
+	});
+
+	it('builds one function per manifest entry, named for the stack', () => {
+		const functions = Function.fromManifest(
+			stack,
+			{
+				billing: [
+					{
+						name: 'Invoice',
+						handler: '.gkm/aws-lambda/functions/invoice.handler',
+						environment: ['DB_URL'],
+						timeout: 60,
+						memorySize: 512,
+					},
+				],
+				ops: [
+					{
+						name: 'Ping',
+						handler: '.gkm/aws-lambda/functions/ping.handler',
+						environment: [],
+					},
+				],
+			} as never,
+			{ links: [db] },
+		);
+
+		expect(functions.map((f) => argsOf(f))).toEqual([
+			expect.objectContaining({
+				name: stack.logicalPrefixedName('Invoice'),
+				timeout: '60 seconds',
+				memory: '512 MB',
+				link: [db],
+			}),
+			expect.objectContaining({
+				name: stack.logicalPrefixedName('Ping'),
+				timeout: undefined,
+				memory: undefined,
+				link: [],
+			}),
+		]);
+	});
+});
+
+describe('Cron', () => {
+	it('schedules the function it is given, by ARN', () => {
+		const processor = { arn: 'arn:aws:lambda:eu-west-1:1:function:nightly' };
+		const cron = new Cron(stack, 'Nightly', {
+			processor: processor as never,
+			schedule: 'rate(1 day)',
+			enabled: false,
+		});
+
+		expect(argsOf(cron)).toEqual({
+			enabled: false,
+			schedule: 'rate(1 day)',
+			function: processor.arn,
+		});
+	});
+
+	it('builds a validated function and a schedule per manifest cron', () => {
+		const crons = Cron.fromManifest(
+			stack,
+			[
+				{
+					name: 'Digest',
+					handler: '.gkm/aws-lambda/crons/digest.handler',
+					schedule: 'cron(0 8 * * ? *)',
+					environment: ['DB_URL'],
+					timeout: 120,
+					memorySize: 1024,
+				},
+				{
+					name: 'Sweep',
+					handler: '.gkm/aws-lambda/crons/sweep.handler',
+					schedule: 'rate(1 hour)',
+					environment: [],
+				},
+			] as never,
+			{ links: [db], enabled: true },
+		);
+
+		const [digest, sweep] = crons.map((c) => argsOf(c));
+		expect(digest).toMatchObject({
+			schedule: 'cron(0 8 * * ? *)',
+			enabled: true,
+			function: expect.stringContaining('DigestFunction'),
+		});
+		expect(sweep).toMatchObject({ schedule: 'rate(1 hour)' });
+	});
+});
+
+describe('App and Stack', () => {
+	it('pick a value for the stage, falling back to the default', () => {
+		expect(app.select({ prod: 'live', default: 'test' })).toBe('live');
+		expect(stack.select({ staging: 'test', default: 'dev' } as never)).toBe(
+			'dev',
+		);
+	});
+
+	it('name subdomains and URLs under the root domain', () => {
+		expect(stack.domain).toBe('shop.test');
+		expect(stack.getSubdomain('api')).toBe('api.shop.test');
+		expect(stack.getURL('api')).toBe('https://api.shop.test');
+		expect(stack.getURL()).toBe('https://shop.test');
+		expect(app.getURL()).toBe('https://shop.test');
+	});
+
+	it('prefix physical names with the stage, app and stack', () => {
+		expect(app.logicalPrefixedName('Uploads')).toBe('prod-shop-uploads');
+		expect(stack.logicalPrefixedName('Uploads')).toBe('prod-shop-jobs-uploads');
+	});
+});

package/src/sst/__tests__/links.spec.ts

@@ -0,0 +1,209 @@
+import { describe, expect, it } from 'vitest';
+import { Cache, CacheNeedsProvider, CacheNeedsVpc } from '../aws/Cache';
+import { Database } from '../aws/Database';
+import { DatabaseReader, DatabaseSchema } from '../aws/DerivedDatabase';
+import { Email } from '../aws/Email';
+import { FileServer } from '../aws/FileServer';
+import { Queue } from '../aws/Queue';
+import { RestApiSurface } from '../aws/RestApiSurface';
+import { Secret } from '../aws/Secret';
+import { StaticSite } from '../aws/StaticSite';
+import { Storage } from '../aws/Storage';
+import { Topic } from '../aws/Topic';
+import { ResourceType } from '../Linkable';
+
+/**
+ * What a linked function receives from each component, and the type that
+ * decides which variables a link provides. `getSSTLink()` is the payload SST
+ * injects into every handler linked to the resource; `_type` is what
+ * `LinkedEnvironment` keys the variable names off.
+ */
+
+const stack = {} as never;
+const vpc = { subnets: ['subnet-1'], securityGroups: ['sg-1'] } as never;
+
+/** Resolves `$util.output(promise)`, which the stub leaves as the promise. */
+const settle = async (value: unknown) =>
+	(value as { apply: (fn: (v: unknown) => unknown) => unknown }).apply(
+		(v) => v,
+	);
+
+describe('link payloads', () => {
+	it('a queue adds its ARN and connection string to SST’s own link', () => {
+		const queue = new Queue(stack, 'Emails');
+
+		expect(queue._type).toBe(ResourceType.Queue);
+		// The connection string itself is parsed back in provides.spec; here, the
+		// link carries exactly what `provides()` resolved.
+		expect(queue.getSSTLink().properties).toEqual({
+			name: 'Emails',
+			arn: queue.arn,
+			...queue.provides(),
+		});
+	});
+
+	it('a topic carries its publisher connection string', () => {
+		const topic = new Topic(stack, 'Users');
+
+		expect(topic._type).toBe(ResourceType.SnsTopic);
+		expect(topic.getSSTLink().properties).toEqual({
+			name: 'Users',
+			...topic.provides(),
+		});
+	});
+
+	it('a secret carries its value', () => {
+		const secret = new Secret(stack, 'AuthSecret');
+
+		expect(secret._type).toBe(ResourceType.SSTSecret);
+		expect(secret.getSSTLink().properties).toMatchObject(secret.provides());
+	});
+
+	it('a mailer carries its URL and sending identity, and nothing else', () => {
+		const email = new Email(stack, 'Mail', {
+			backend: 'smtp',
+			url: 'smtp://relay.test:587',
+			from: 'hello@shop.test',
+		} as never);
+
+		expect(email._type).toBe(ResourceType.Email);
+		expect(email.getSSTLink()).toEqual({
+			properties: { url: 'smtp://relay.test:587', from: 'hello@shop.test' },
+		});
+	});
+
+	it('a file server routes everything to its bucket, and links its URL', () => {
+		const origin = new Storage(stack, 'Uploads');
+		const server = new FileServer(stack, 'Files', { origin } as never);
+
+		expect(origin._type).toBe(ResourceType.ObjectStorage);
+		expect(origin._id).toBe('Uploads');
+		expect(server._type).toBe(ResourceType.FileServer);
+		expect((server as unknown as { routed: unknown[] }).routed).toEqual([
+			{ pattern: '/*', bucket: origin },
+		]);
+		expect(server.getSSTLink().properties).toMatchObject({
+			url: server.url,
+		});
+	});
+
+	it('a site is built the way its variant builds, and links its URL', () => {
+		const vite = new StaticSite(stack, 'Web');
+		const next = new StaticSite(stack, 'Admin', {
+			variant: 'next',
+			build: { command: 'pnpm build:custom', output: 'out' },
+		} as never);
+		const args = (site: unknown) => (site as { args: { build: unknown } }).args;
+
+		expect(vite._type).toBe(ResourceType.StaticSite);
+		expect(args(vite).build).toEqual(expect.objectContaining({}));
+		// A build the caller supplied wins over the variant's.
+		expect(args(next).build).toEqual({
+			command: 'pnpm build:custom',
+			output: 'out',
+		});
+		expect(vite.getSSTLink().properties).toMatchObject({ url: vite.url });
+	});
+
+	it('a surface links its address and, once resolved, who may call it', async () => {
+		const bare = new RestApiSurface(stack, 'Api');
+		const called = new RestApiSurface(stack, 'Api', {
+			callers: Promise.resolve({
+				trustedOrigins: 'https://web.shop.test',
+				cookieDomain: 'shop.test',
+			}),
+		});
+
+		expect(bare._type).toBe(ResourceType.ApiGatewayV2);
+		expect(await settle(bare.provides().trustedOrigins)).toBe('');
+		expect(await settle(bare.provides().cookieDomain)).toBe('');
+
+		const link = called.getSSTLink().properties as Record<string, unknown>;
+		expect(link.url).toBe(called.url);
+		expect(await settle(link.trustedOrigins)).toBe('https://web.shop.test');
+		expect(await settle(link.cookieDomain)).toBe('shop.test');
+	});
+
+	it('a database and the nodes derived from it each link only their own URL', () => {
+		const cluster = new Database(stack, 'Orders', { vpc, schema: 'app' });
+		const reader = new DatabaseReader('OrdersReader', cluster);
+		const tenant = new DatabaseSchema('AuthDb', cluster, 'authdb');
+
+		expect(cluster._type).toBe(ResourceType.SSTPostgres);
+		expect(reader._type).toBe(ResourceType.SSTPostgres);
+		expect(tenant._type).toBe(ResourceType.SSTPostgres);
+		expect(cluster.getSSTLink().properties).toMatchObject({
+			url: cluster.provides().url,
+		});
+		// Least privilege: the reader's link is its URL and not the writer's.
+		expect(reader.getSSTLink()).toEqual({
+			properties: { url: reader.provides().url },
+		});
+		expect(tenant.getSSTLink()).toEqual({
+			properties: { url: tenant.provides().url },
+		});
+	});
+
+	it('a cache given its URL links it as-is', () => {
+		const cache = new Cache(stack, 'Sessions', {
+			backend: 'db',
+			url: 'postgres://db.test/app',
+		});
+
+		expect(cache._type).toBe(ResourceType.Cache);
+		expect(cache.getSSTLink()).toEqual({
+			properties: { url: 'postgres://db.test/app' },
+		});
+	});
+});
+
+describe('Cache on Upstash', () => {
+	/** `sst add upstash` installs this global; here, a recording stand-in. */
+	const created: { name: string; args: Record<string, unknown> }[] = [];
+	class RedisDatabase {
+		readonly endpoint = 'eu1-cache.upstash.io';
+		readonly restToken = 'tok/en+1';
+		constructor(name: string, args: Record<string, unknown>) {
+			created.push({ name, args });
+		}
+	}
+
+	it('creates a TLS database and puts its token in the URL', () => {
+		(globalThis as Record<string, unknown>).upstash = { RedisDatabase };
+		try {
+			const defaulted = new Cache(stack, 'Sessions', { backend: 'upstash' });
+			new Cache(stack, 'Rates', { backend: 'upstash', region: 'us-east-1' });
+
+			expect(created).toEqual([
+				{
+					name: 'SessionsCache',
+					args: { databaseName: 'Sessions', region: 'eu-west-1', tls: true },
+				},
+				{
+					name: 'RatesCache',
+					args: { databaseName: 'Rates', region: 'us-east-1', tls: true },
+				},
+			]);
+			// The address and the credential that opens it are one fact.
+			expect(defaulted.provides().url).toBe(
+				`https://:${encodeURIComponent('tok/en+1')}@eu1-cache.upstash.io`,
+			);
+		} finally {
+			delete (globalThis as Record<string, unknown>).upstash;
+		}
+	});
+});
+
+describe('Cache provisioning refusals', () => {
+	it('asks for the Upstash provider when it is not installed', () => {
+		expect(() => new Cache(stack, 'Sessions', { backend: 'upstash' })).toThrow(
+			CacheNeedsProvider,
+		);
+	});
+
+	it('asks for a VPC before creating an ElastiCache', () => {
+		expect(
+			() => new Cache(stack, 'Sessions', { backend: 'elasticache' }),
+		).toThrow(CacheNeedsVpc);
+	});
+});

package/src/sst/aws/Database.ts

@@ -84,7 +84,21 @@ export class Database<
 	 * produces a database that looks empty.
 	 */
 	provides(): Record<string, $util.Input<string>> {
-		return { url: this.urlFor({}) };
+		return { url: this.urlFor(this.role ? { as: this.role } : {}) };
+	}
+
+	/**
+	 * The runtime role this database's own handlers connect as.
+	 *
+	 * Set by the adapter once the bootstrap has registered the role — the
+	 * cluster exists before any role does, so it cannot be a constructor
+	 * argument. Until it is set (and under `roles: false`, where it never is),
+	 * the URL is the master's.
+	 */
+	private role: { user: string; password: $util.Input<string> } | undefined;
+
+	connectAs(role: { user: string; password: $util.Input<string> }): void {
+		this.role = role;
 	}
 
 	/**

package/src/sst/fromManifest.ts

@@ -232,13 +232,20 @@ const PROVISIONERS: Partial<Record<DeclarationKind, Provisioner>> = {
 			const bootstrap = bootstrapFor(cluster, d.id, context);
 			const runtime = roleNameFor(d, context);
 
-			bootstrap?.add({
+			const credentials = bootstrap?.add({
 				id: d.id,
 				schema: d.schema,
 				runtime,
 				owner: ownerRole(runtime),
 				...(hasReader(d.id, context) ? { reader: readerRole(runtime) } : {}),
 			});
+
+			// Registering the role was half of it: its handlers have to connect as
+			// it too, or the DDL creates a role nothing uses and every handler
+			// linked to the database still holds the master.
+			if (credentials) {
+				cluster.connectAs({ user: runtime, password: credentials.runtime });
+			}
 		}
 
 		return cluster;

package/dist/index-B5CZ1xVf.d.cts

@@ -1,64 +0,0 @@
-//#region src/utils/index.d.ts
-declare function getLocalIpAddress(): string | null;
-declare function environmentCase(name: string): string;
-declare enum ResourceType {
-  ApiGatewayV2 = "sst.aws.ApiGatewayV2",
-  Postgres = "sst.aws.Postgres",
-  Function = "sst.aws.Function",
-  ObjectStorage = "sst.aws.Bucket",
-  Vpc = "sst.aws.Vpc",
-  Secret = "sst.sst.Secret",
-  SSTSecret = "sst:sst:Secret",
-  SSTFunction = "sst:sst:Function",
-  SSTApiGatewayV2 = "sst:aws:ApiGatewayV2",
-  SSTPostgres = "sst:aws:Postgres",
-  SSTObjectStorage = "sst:aws:Bucket",
-  SnsTopic = "sst:aws:SnsTopic",
-}
-declare function buildResourceEnv(record: Record<string, Resource | string>): Record<string, string>;
-/**
- * SST links a resource under one of two spellings — `sst.aws.Bucket` when it
- * comes from the state file, `sst:aws:Bucket` when it comes from the runtime —
- * and `processors` has always handled both. Only the dotted half was admitted
- * here, so the colon half could not be passed to `buildResourceEnv` without a
- * cast, and `SnsTopic` was missing from `Resource` altogether despite being the
- * only thing that produces `*_ARN`.
- */
-type ApiGatewayV2 = {
-  type: ResourceType.ApiGatewayV2 | ResourceType.SSTApiGatewayV2;
-  url: string;
-};
-type Postgres = {
-  database: string;
-  host: string;
-  password: string;
-  port: number;
-  type: ResourceType.Postgres | ResourceType.SSTPostgres;
-  username: string;
-};
-type Function = {
-  name: string;
-  type: ResourceType.Function | ResourceType.SSTFunction;
-};
-type Bucket = {
-  name: string;
-  type: ResourceType.ObjectStorage | ResourceType.SSTObjectStorage;
-};
-type SnsTopic = {
-  arn: string;
-  type: ResourceType.SnsTopic;
-};
-type Vpc = {
-  bastion: string;
-  type: ResourceType.Vpc;
-};
-type Secret = {
-  type: ResourceType.Secret | ResourceType.SSTSecret;
-  value: string;
-};
-type Resource = ApiGatewayV2 | Postgres | Function | Bucket | SnsTopic | Vpc | Secret;
-type ResourceProcessor<K extends Resource> = (name: string, value: K) => Record<string, string | number>;
-//# sourceMappingURL=index.d.ts.map
-//#endregion
-export { ApiGatewayV2, Bucket, Function, Postgres, Resource, ResourceProcessor, ResourceType, Secret, SnsTopic, Vpc, buildResourceEnv, environmentCase, getLocalIpAddress };
-//# sourceMappingURL=index-B5CZ1xVf.d.cts.map

package/dist/index-B5CZ1xVf.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index-B5CZ1xVf.d.cts","names":[],"sources":["../src/utils/index.ts"],"sourcesContent":[],"mappings":";iBAGgB,iBAAA,CAAA;AAAA,iBAcA,eAAA,CAdiB,IAAA,EAAA,MAAA,CAAA,EAAA,MAAA;AAcjB,aAOJ,YAAA;EAAA,YAAA,GAAY,sBAAA;EA+DR,QAAA,GAAA,kBAAgB;EAAA,QAAA,GAAA,kBAAA;EAAA,aACR,GAAA,gBAAA;EAAQ,GAAvB,GAAA,aAAA;EAAM,MACZ,GAAA,gBAAA;EAAM,SAAA,GAAA,gBAAA;EA0BG,WAAA,GAAA,kBAAY;EAAA,eAAA,GAAA,sBAAA;EAAA,WACjB,GAAA,kBAAa;EAAY,gBAAgB,GAAA,gBAAA;EAAe,QAAA,GAAA,kBAAA;AAI/D;AAAoB,iBAjCJ,gBAAA,CAiCI,MAAA,EAhCX,MAgCW,CAAA,MAAA,EAhCI,QAgCJ,GAAA,MAAA,CAAA,CAAA,EA/BjB,MA+BiB,CAAA,MAAA,EAAA,MAAA,CAAA;;;AAKmC;AAIvD;;;;AAEuD;AAG3C,KAnBA,YAAA,GAmBM;EAAA,IAAA,EAlBX,YAAA,CAAa,YAkBF,GAlBiB,YAAA,CAAa,eAkB9B;EAAA,GAEX,EAAA,MAAA;CAA0B;AAAgC,KAhBrD,QAAA,GAgBqD;EAGrD,QAAA,EAAA,MAAQ;EAKR,IAAA,EAAG,MAAA;EAKH,QAAA,EAAM,MAAA;EAAA,IAAA,EAAA,MAAA;EAAA,IACX,EAzBA,YAAA,CAAa,QAyBA,GAzBW,YAAA,CAAa,WAyBxB;EAAM,QAAG,EAAA,MAAa;AAAS,CAAA;AAIvC,KAzBA,QAAA,GAyBQ;EAAA,IAAA,EAAA,MAAA;EAAA,IACjB,EAxBI,YAAA,CAAa,QAwBjB,GAxB4B,YAAA,CAAa,WAwBzC;CAAY;AAEZ,KAvBS,MAAA,GAuBT;EAAQ,IACR,EAAA,MAAA;EAAM,IACN,EAvBI,YAAA,CAAa,aAuBjB,GAvBiC,YAAA,CAAa,gBAuB9C;CAAQ;AAER,KAtBS,QAAA,GAsBT;EAAM,GAAA,EAAA,MAAA;EAEG,IAAA,EAtBL,YAAA,CAAa,QAsBS;CAAA;AAAW,KAnB5B,GAAA,GAmB4B;EAAQ,OAExC,EAAA,MAAA;EAAC,IACJ,EApBE,YAAA,CAAa,GAoBf;AAAM,CAAA;KAjBC,MAAA;QACL,YAAA,CAAa,SAAS,YAAA,CAAa;;;KAI9B,QAAA,GACT,eACA,WACA,WACA,SACA,WACA,MACA;KAES,4BAA4B,kCAEhC,MACH"}

package/dist/index-DhHRjduZ.d.mts

@@ -1,64 +0,0 @@
-//#region src/utils/index.d.ts
-declare function getLocalIpAddress(): string | null;
-declare function environmentCase(name: string): string;
-declare enum ResourceType {
-  ApiGatewayV2 = "sst.aws.ApiGatewayV2",
-  Postgres = "sst.aws.Postgres",
-  Function = "sst.aws.Function",
-  ObjectStorage = "sst.aws.Bucket",
-  Vpc = "sst.aws.Vpc",
-  Secret = "sst.sst.Secret",
-  SSTSecret = "sst:sst:Secret",
-  SSTFunction = "sst:sst:Function",
-  SSTApiGatewayV2 = "sst:aws:ApiGatewayV2",
-  SSTPostgres = "sst:aws:Postgres",
-  SSTObjectStorage = "sst:aws:Bucket",
-  SnsTopic = "sst:aws:SnsTopic",
-}
-declare function buildResourceEnv(record: Record<string, Resource | string>): Record<string, string>;
-/**
- * SST links a resource under one of two spellings — `sst.aws.Bucket` when it
- * comes from the state file, `sst:aws:Bucket` when it comes from the runtime —
- * and `processors` has always handled both. Only the dotted half was admitted
- * here, so the colon half could not be passed to `buildResourceEnv` without a
- * cast, and `SnsTopic` was missing from `Resource` altogether despite being the
- * only thing that produces `*_ARN`.
- */
-type ApiGatewayV2 = {
-  type: ResourceType.ApiGatewayV2 | ResourceType.SSTApiGatewayV2;
-  url: string;
-};
-type Postgres = {
-  database: string;
-  host: string;
-  password: string;
-  port: number;
-  type: ResourceType.Postgres | ResourceType.SSTPostgres;
-  username: string;
-};
-type Function = {
-  name: string;
-  type: ResourceType.Function | ResourceType.SSTFunction;
-};
-type Bucket = {
-  name: string;
-  type: ResourceType.ObjectStorage | ResourceType.SSTObjectStorage;
-};
-type SnsTopic = {
-  arn: string;
-  type: ResourceType.SnsTopic;
-};
-type Vpc = {
-  bastion: string;
-  type: ResourceType.Vpc;
-};
-type Secret = {
-  type: ResourceType.Secret | ResourceType.SSTSecret;
-  value: string;
-};
-type Resource = ApiGatewayV2 | Postgres | Function | Bucket | SnsTopic | Vpc | Secret;
-type ResourceProcessor<K extends Resource> = (name: string, value: K) => Record<string, string | number>;
-//# sourceMappingURL=index.d.ts.map
-//#endregion
-export { ApiGatewayV2, Bucket, Function, Postgres, Resource, ResourceProcessor, ResourceType, Secret, SnsTopic, Vpc, buildResourceEnv, environmentCase, getLocalIpAddress };
-//# sourceMappingURL=index-DhHRjduZ.d.mts.map

package/dist/index-DhHRjduZ.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index-DhHRjduZ.d.mts","names":[],"sources":["../src/utils/index.ts"],"sourcesContent":[],"mappings":";iBAGgB,iBAAA,CAAA;AAAA,iBAcA,eAAA,CAdiB,IAAA,EAAA,MAAA,CAAA,EAAA,MAAA;AAcjB,aAOJ,YAAA;EAAA,YAAA,GAAY,sBAAA;EA+DR,QAAA,GAAA,kBAAgB;EAAA,QAAA,GAAA,kBAAA;EAAA,aACR,GAAA,gBAAA;EAAQ,GAAvB,GAAA,aAAA;EAAM,MACZ,GAAA,gBAAA;EAAM,SAAA,GAAA,gBAAA;EA0BG,WAAA,GAAA,kBAAY;EAAA,eAAA,GAAA,sBAAA;EAAA,WACjB,GAAA,kBAAa;EAAY,gBAAgB,GAAA,gBAAA;EAAe,QAAA,GAAA,kBAAA;AAI/D;AAAoB,iBAjCJ,gBAAA,CAiCI,MAAA,EAhCX,MAgCW,CAAA,MAAA,EAhCI,QAgCJ,GAAA,MAAA,CAAA,CAAA,EA/BjB,MA+BiB,CAAA,MAAA,EAAA,MAAA,CAAA;;;AAKmC;AAIvD;;;;AAEuD;AAG3C,KAnBA,YAAA,GAmBM;EAAA,IAAA,EAlBX,YAAA,CAAa,YAkBF,GAlBiB,YAAA,CAAa,eAkB9B;EAAA,GAEX,EAAA,MAAA;CAA0B;AAAgC,KAhBrD,QAAA,GAgBqD;EAGrD,QAAA,EAAA,MAAQ;EAKR,IAAA,EAAG,MAAA;EAKH,QAAA,EAAM,MAAA;EAAA,IAAA,EAAA,MAAA;EAAA,IACX,EAzBA,YAAA,CAAa,QAyBA,GAzBW,YAAA,CAAa,WAyBxB;EAAM,QAAG,EAAA,MAAa;AAAS,CAAA;AAIvC,KAzBA,QAAA,GAyBQ;EAAA,IAAA,EAAA,MAAA;EAAA,IACjB,EAxBI,YAAA,CAAa,QAwBjB,GAxB4B,YAAA,CAAa,WAwBzC;CAAY;AAEZ,KAvBS,MAAA,GAuBT;EAAQ,IACR,EAAA,MAAA;EAAM,IACN,EAvBI,YAAA,CAAa,aAuBjB,GAvBiC,YAAA,CAAa,gBAuB9C;CAAQ;AAER,KAtBS,QAAA,GAsBT;EAAM,GAAA,EAAA,MAAA;EAEG,IAAA,EAtBL,YAAA,CAAa,QAsBS;CAAA;AAAW,KAnB5B,GAAA,GAmB4B;EAAQ,OAExC,EAAA,MAAA;EAAC,IACJ,EApBE,YAAA,CAAa,GAoBf;AAAM,CAAA;KAjBC,MAAA;QACL,YAAA,CAAa,SAAS,YAAA,CAAa;;;KAI9B,QAAA,GACT,eACA,WACA,WACA,SACA,WACA,MACA;KAES,4BAA4B,kCAEhC,MACH"}