@geekmidas/cloud 10.0.0-alpha.17 → 10.0.0-alpha.170
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/README.md +26 -6
- package/package.json +9 -8
- package/src/sst/__tests__/api.spec.ts +0 -46
- package/src/sst/__tests__/bootstrap.spec.ts +15 -0
- package/src/sst/__tests__/encryption.spec.ts +90 -0
- package/src/sst/__tests__/fromManifest.inbox.spec.ts +157 -0
- package/src/sst/__tests__/fromManifest.integration.spec.ts +87 -3
- package/src/sst/__tests__/fromManifest.secret.spec.ts +79 -0
- package/src/sst/__tests__/fromManifest.spec.ts +412 -18
- package/src/sst/__tests__/function.spec.ts +0 -71
- package/src/sst/__tests__/hostLabels.spec.ts +74 -0
- package/src/sst/__tests__/surfaces.spec.ts +68 -5
- package/src/sst/__tests__/websocket.spec.ts +207 -0
- package/src/sst/__tests__/wildcardSite.spec.ts +195 -0
- package/src/sst/__type-tests__/overrides.type-test.ts +152 -0
- package/src/sst/aws/Api.ts +0 -43
- package/src/sst/aws/Credential.ts +42 -9
- package/src/sst/aws/Cron.ts +5 -45
- package/src/sst/aws/DatabaseBootstrap.ts +6 -0
- package/src/sst/aws/Encryption.ts +91 -0
- package/src/sst/aws/ExternalApi.ts +58 -0
- package/src/sst/aws/Function.ts +9 -38
- package/src/sst/aws/Inbox.ts +141 -0
- package/src/sst/aws/ObjectStorage.ts +3 -3
- package/src/sst/aws/Queue.ts +34 -1
- package/src/sst/aws/RestApiSurface.ts +36 -14
- package/src/sst/aws/Secret.ts +6 -4
- package/src/sst/aws/StaticSite.ts +44 -1
- package/src/sst/aws/WebSocketApiSurface.ts +160 -0
- package/src/sst/aws/bootstrap/handler.ts +12 -1
- package/src/sst/errors.ts +37 -0
- package/src/sst/fromManifest.ts +624 -71
- package/src/sst/index.ts +21 -1
- package/src/sst/overrides.ts +149 -0
- package/src/sst/__type-tests__/manifest.type-test.ts +0 -77
package/src/sst/aws/Api.ts
CHANGED
|
@@ -1,10 +1,5 @@
|
|
|
1
1
|
import path from 'node:path';
|
|
2
2
|
import { EnvValidationError } from '@geekmidas/envkit/sst';
|
|
3
|
-
import {
|
|
4
|
-
flattenManifestField,
|
|
5
|
-
type ManifestField,
|
|
6
|
-
type RouteInfo,
|
|
7
|
-
} from '@geekmidas/manifest';
|
|
8
3
|
import { type GkmLinkable, ResourceType } from '../Linkable';
|
|
9
4
|
import { LinkedEnvironment } from '../LinkedEnvironment';
|
|
10
5
|
import type { StackType } from '../Stack';
|
|
@@ -157,44 +152,6 @@ export class Api<
|
|
|
157
152
|
}
|
|
158
153
|
}
|
|
159
154
|
|
|
160
|
-
/**
|
|
161
|
-
* Build an `Api` from a `gkm build` manifest's `routes` field (flat or
|
|
162
|
-
* partitioned): each `RouteInfo` becomes a route (env vars, authorizer,
|
|
163
|
-
* timeout/memory mapped). Supply `authorizers` (JWT/Lambda settings),
|
|
164
|
-
* `links`, and any native args via `props`.
|
|
165
|
-
*
|
|
166
|
-
* ```ts
|
|
167
|
-
* import { manifest } from './.gkm/manifest/aws';
|
|
168
|
-
* Api.fromManifest(stack, 'Api', manifest.routes, { links: [db] });
|
|
169
|
-
* ```
|
|
170
|
-
*/
|
|
171
|
-
static fromManifest<
|
|
172
|
-
TAuthorizers extends Record<string, unknown> = {},
|
|
173
|
-
TStage extends string = string,
|
|
174
|
-
TDomain extends string = string,
|
|
175
|
-
>(
|
|
176
|
-
stack: StackType<TStage, TDomain>,
|
|
177
|
-
id: string,
|
|
178
|
-
routes: ManifestField<RouteInfo>,
|
|
179
|
-
props: Omit<ApiProps<TAuthorizers>, 'routes'> = {},
|
|
180
|
-
): Api<TAuthorizers, TStage, TDomain> {
|
|
181
|
-
const routeTable = flattenManifestField(routes).map(
|
|
182
|
-
(route): Route<AuthorizerName<TAuthorizers>> => ({
|
|
183
|
-
method: route.method as Route['method'],
|
|
184
|
-
path: route.path,
|
|
185
|
-
handler: route.handler,
|
|
186
|
-
environment: route.environment,
|
|
187
|
-
authorizer: route.authorizer as AuthorizerName<TAuthorizers>,
|
|
188
|
-
timeout: route.timeout ? `${route.timeout} seconds` : undefined,
|
|
189
|
-
memory: route.memorySize ? `${route.memorySize} MB` : undefined,
|
|
190
|
-
}),
|
|
191
|
-
);
|
|
192
|
-
return new Api(stack, id, {
|
|
193
|
-
...props,
|
|
194
|
-
routes: routeTable,
|
|
195
|
-
} as ApiProps<TAuthorizers>);
|
|
196
|
-
}
|
|
197
|
-
|
|
198
155
|
/** Resolves a route's `authorizer` name to the SST `auth` option. */
|
|
199
156
|
private static buildRouteAuth(
|
|
200
157
|
route: Route<string>,
|
|
@@ -1,4 +1,5 @@
|
|
|
1
|
-
import {
|
|
1
|
+
import { type GkmLinkable, ResourceType } from '../Linkable';
|
|
2
|
+
import type { StackType } from '../Stack';
|
|
2
3
|
|
|
3
4
|
/**
|
|
4
5
|
* `Credential` — a third-party credential SST holds, and the infra half of the
|
|
@@ -8,21 +9,53 @@ import { Secret, type SecretProps } from './Secret';
|
|
|
8
9
|
* the lifecycle rather than the mechanism: a secret is generated and rotated by
|
|
9
10
|
* the platform, while a credential is issued by someone else and has a shape
|
|
10
11
|
* the construct validates on the way in. Both are values you set out of band
|
|
11
|
-
* with `sst secret set
|
|
12
|
+
* with `sst secret set`, under the construct's id.
|
|
12
13
|
*
|
|
13
|
-
* The role is `
|
|
14
|
+
* The role is `credentials` rather than `value`, and that is not cosmetic. The
|
|
14
15
|
* role *is* the contract — `providedKeyFor` turns it into the key the app
|
|
15
16
|
* declared — so a credential providing `value` would supply `STRIPE_VALUE`
|
|
16
|
-
* against a declared `
|
|
17
|
-
* stack at synth.
|
|
17
|
+
* against a declared `STRIPE_CREDENTIALS`, and `assertProvides` would reject
|
|
18
|
+
* the stack at synth.
|
|
19
|
+
*
|
|
20
|
+
* It holds an `sst.Secret` rather than being one, and reports its own type,
|
|
21
|
+
* for the same reason one level down: the type decides the keys a link
|
|
22
|
+
* resolves to. As an SST secret it resolved to `STRIPE`, so a function that
|
|
23
|
+
* declared `STRIPE_CREDENTIALS` was linked to nothing.
|
|
18
24
|
*/
|
|
19
25
|
export class Credential<
|
|
20
26
|
TStage extends string = string,
|
|
21
27
|
TDomain extends string = string,
|
|
22
|
-
>
|
|
23
|
-
|
|
24
|
-
|
|
28
|
+
> implements GkmLinkable
|
|
29
|
+
{
|
|
30
|
+
readonly _id: string;
|
|
31
|
+
|
|
32
|
+
private readonly secret: sst.Secret;
|
|
33
|
+
|
|
34
|
+
get _type() {
|
|
35
|
+
return ResourceType.Credential;
|
|
36
|
+
}
|
|
37
|
+
|
|
38
|
+
constructor(
|
|
39
|
+
_stack: StackType<TStage, TDomain>,
|
|
40
|
+
name: string,
|
|
41
|
+
props: CredentialProps = {},
|
|
42
|
+
) {
|
|
43
|
+
this._id = name;
|
|
44
|
+
// The id itself, as it always was: a value already set with
|
|
45
|
+
// `sst secret set Stripe …` is still the one read.
|
|
46
|
+
this.secret = new sst.Secret(name, props.placeholder);
|
|
47
|
+
}
|
|
48
|
+
|
|
49
|
+
provides(): Record<string, $util.Input<string>> {
|
|
50
|
+
return { credentials: this.secret.value };
|
|
51
|
+
}
|
|
52
|
+
|
|
53
|
+
getSSTLink() {
|
|
54
|
+
return { properties: { ...this.provides() } };
|
|
25
55
|
}
|
|
26
56
|
}
|
|
27
57
|
|
|
28
|
-
export interface CredentialProps
|
|
58
|
+
export interface CredentialProps {
|
|
59
|
+
/** A value until one is set, for a preview stage. */
|
|
60
|
+
placeholder?: string;
|
|
61
|
+
}
|
package/src/sst/aws/Cron.ts
CHANGED
|
@@ -1,11 +1,5 @@
|
|
|
1
|
-
import {
|
|
2
|
-
type CronInfo,
|
|
3
|
-
flattenManifestField,
|
|
4
|
-
type ManifestField,
|
|
5
|
-
} from '@geekmidas/manifest';
|
|
6
|
-
import type { GkmLinkable } from '../Linkable';
|
|
7
1
|
import type { StackType } from '../Stack';
|
|
8
|
-
import { Function } from './Function';
|
|
2
|
+
import type { Function } from './Function';
|
|
9
3
|
|
|
10
4
|
export type CronExpressionValue = number | '*' | '?' | `${number}/${number}`;
|
|
11
5
|
export type CronExpressionDay =
|
|
@@ -52,6 +46,9 @@ export class Cron<
|
|
|
52
46
|
TStage extends string = string,
|
|
53
47
|
TDomain extends string = string,
|
|
54
48
|
> extends sst.aws.CronV2 {
|
|
49
|
+
/** The function it invokes. */
|
|
50
|
+
readonly processor: CronProps['processor'];
|
|
51
|
+
|
|
55
52
|
constructor(
|
|
56
53
|
_stack: StackType<TStage, TDomain>,
|
|
57
54
|
name: string,
|
|
@@ -63,44 +60,7 @@ export class Cron<
|
|
|
63
60
|
schedule,
|
|
64
61
|
function: processor.arn,
|
|
65
62
|
});
|
|
66
|
-
|
|
67
|
-
|
|
68
|
-
/**
|
|
69
|
-
* Build one `Cron` per entry in a `gkm build` manifest's `crons` field (flat
|
|
70
|
-
* or partitioned). Each cron's handler becomes a validated `Function` (the
|
|
71
|
-
* cron's target), so pass `links` for that function's env validation;
|
|
72
|
-
* remaining `props` are CronV2 args.
|
|
73
|
-
*
|
|
74
|
-
* ```ts
|
|
75
|
-
* Cron.fromManifest(stack, manifest.crons, { links: [db] });
|
|
76
|
-
* ```
|
|
77
|
-
*/
|
|
78
|
-
static fromManifest<
|
|
79
|
-
TStage extends string = string,
|
|
80
|
-
TDomain extends string = string,
|
|
81
|
-
>(
|
|
82
|
-
stack: StackType<TStage, TDomain>,
|
|
83
|
-
crons: ManifestField<CronInfo>,
|
|
84
|
-
props: Omit<CronProps, 'processor' | 'schedule'> & {
|
|
85
|
-
links?: GkmLinkable[];
|
|
86
|
-
} = {},
|
|
87
|
-
): Cron<TStage, TDomain>[] {
|
|
88
|
-
const { links, ...cronArgs } = props;
|
|
89
|
-
return flattenManifestField(crons).map((cron) => {
|
|
90
|
-
const processor = new Function(stack, `${cron.name}Function`, {
|
|
91
|
-
name: stack.logicalPrefixedName(cron.name),
|
|
92
|
-
handler: cron.handler,
|
|
93
|
-
envVars: cron.environment,
|
|
94
|
-
links,
|
|
95
|
-
timeout: cron.timeout ? `${cron.timeout} seconds` : undefined,
|
|
96
|
-
memory: cron.memorySize ? `${cron.memorySize} MB` : undefined,
|
|
97
|
-
});
|
|
98
|
-
return new Cron(stack, cron.name, {
|
|
99
|
-
...cronArgs,
|
|
100
|
-
processor,
|
|
101
|
-
schedule: cron.schedule as CronSchedule,
|
|
102
|
-
});
|
|
103
|
-
});
|
|
63
|
+
this.processor = processor;
|
|
104
64
|
}
|
|
105
65
|
}
|
|
106
66
|
|
|
@@ -65,6 +65,10 @@ export class DatabaseBootstrap {
|
|
|
65
65
|
runtime: string;
|
|
66
66
|
owner: string;
|
|
67
67
|
reader?: string;
|
|
68
|
+
/** The database's own roles, whose owner may create in it. */
|
|
69
|
+
ownsDatabase?: boolean;
|
|
70
|
+
/** Extensions the database declared, created as the master. */
|
|
71
|
+
extensions?: readonly string[];
|
|
68
72
|
}): { runtime: $util.Output<string>; reader?: $util.Output<string> } {
|
|
69
73
|
const runtime = this.password(tenant.runtime);
|
|
70
74
|
const reader = tenant.reader ? this.password(tenant.reader) : undefined;
|
|
@@ -75,6 +79,8 @@ export class DatabaseBootstrap {
|
|
|
75
79
|
runtime: tenant.runtime,
|
|
76
80
|
owner: tenant.owner,
|
|
77
81
|
...(tenant.reader ? { reader: tenant.reader } : {}),
|
|
82
|
+
...(tenant.ownsDatabase ? { ownsDatabase: true } : {}),
|
|
83
|
+
...(tenant.extensions?.length ? { extensions: tenant.extensions } : {}),
|
|
78
84
|
// Filled in by `bootstrapEvent` once the outputs resolve. The function
|
|
79
85
|
// reads them straight out of its input and never fetches a secret, so
|
|
80
86
|
// it needs no IAM to read one.
|
|
@@ -0,0 +1,91 @@
|
|
|
1
|
+
import { kmsUrl } from '@geekmidas/manifest';
|
|
2
|
+
import { kms } from '@pulumi/aws';
|
|
3
|
+
import { type GkmLinkable, ResourceType } from '../Linkable';
|
|
4
|
+
import type { StackType } from '../Stack';
|
|
5
|
+
|
|
6
|
+
/**
|
|
7
|
+
* `Encryption` — two KMS keys, and the infra half of the `encryption` kind.
|
|
8
|
+
*
|
|
9
|
+
* One key encrypts, by envelope: each value is sealed with a data key KMS
|
|
10
|
+
* mints and wraps, so the key itself never leaves KMS. It rotates yearly, and
|
|
11
|
+
* KMS keeps every version it rotated through, so nothing written is ever
|
|
12
|
+
* stranded. The other is an HMAC key for the blind index, which does not
|
|
13
|
+
* rotate — a rotated index key would make every stored index miss.
|
|
14
|
+
*
|
|
15
|
+
* Both are reached through one `kms://` URL, and a function linked to this is
|
|
16
|
+
* granted exactly the calls the cipher makes on exactly these two keys. Not
|
|
17
|
+
* `kms:*`, and not any other key in the account.
|
|
18
|
+
*
|
|
19
|
+
* It holds the keys rather than being one, and reports its own type, so a link
|
|
20
|
+
* resolves to `<ID>_URL` — the key the construct declared.
|
|
21
|
+
*/
|
|
22
|
+
export class Encryption<
|
|
23
|
+
TStage extends string = string,
|
|
24
|
+
TDomain extends string = string,
|
|
25
|
+
> implements GkmLinkable
|
|
26
|
+
{
|
|
27
|
+
readonly _id: string;
|
|
28
|
+
|
|
29
|
+
readonly key: kms.Key;
|
|
30
|
+
readonly indexKey: kms.Key;
|
|
31
|
+
private readonly region: string;
|
|
32
|
+
|
|
33
|
+
get _type() {
|
|
34
|
+
return ResourceType.Encryption;
|
|
35
|
+
}
|
|
36
|
+
|
|
37
|
+
constructor(
|
|
38
|
+
_stack: StackType<TStage, TDomain>,
|
|
39
|
+
name: string,
|
|
40
|
+
props: EncryptionProps,
|
|
41
|
+
) {
|
|
42
|
+
this._id = name;
|
|
43
|
+
this.region = props.region;
|
|
44
|
+
|
|
45
|
+
this.key = new kms.Key(`${name}Key`, {
|
|
46
|
+
description: `${name}: encrypts what the application stores`,
|
|
47
|
+
enableKeyRotation: true,
|
|
48
|
+
deletionWindowInDays: props.deletionWindowInDays ?? 30,
|
|
49
|
+
});
|
|
50
|
+
this.indexKey = new kms.Key(`${name}IndexKey`, {
|
|
51
|
+
description: `${name}: the blind index's HMAC key`,
|
|
52
|
+
keyUsage: 'GENERATE_VERIFY_MAC',
|
|
53
|
+
customerMasterKeySpec: 'HMAC_256',
|
|
54
|
+
deletionWindowInDays: props.deletionWindowInDays ?? 30,
|
|
55
|
+
});
|
|
56
|
+
}
|
|
57
|
+
|
|
58
|
+
provides(): Record<string, $util.Input<string>> {
|
|
59
|
+
return {
|
|
60
|
+
url: $util
|
|
61
|
+
.all([this.key.arn, this.indexKey.arn])
|
|
62
|
+
.apply(([key, index]) => kmsUrl({ region: this.region, key, index })),
|
|
63
|
+
};
|
|
64
|
+
}
|
|
65
|
+
|
|
66
|
+
getSSTLink() {
|
|
67
|
+
return {
|
|
68
|
+
properties: { ...this.provides() },
|
|
69
|
+
include: [
|
|
70
|
+
sst.aws.permission({
|
|
71
|
+
actions: ['kms:GenerateDataKey', 'kms:Decrypt'],
|
|
72
|
+
resources: [this.key.arn],
|
|
73
|
+
}),
|
|
74
|
+
sst.aws.permission({
|
|
75
|
+
actions: ['kms:GenerateMac'],
|
|
76
|
+
resources: [this.indexKey.arn],
|
|
77
|
+
}),
|
|
78
|
+
],
|
|
79
|
+
};
|
|
80
|
+
}
|
|
81
|
+
}
|
|
82
|
+
|
|
83
|
+
export interface EncryptionProps {
|
|
84
|
+
/** Where the keys live — the stage's region. */
|
|
85
|
+
region: string;
|
|
86
|
+
/**
|
|
87
|
+
* How long a deleted key can still be recovered, 7–30 days. A key's
|
|
88
|
+
* deletion is the deletion of everything it encrypted, so the longest.
|
|
89
|
+
*/
|
|
90
|
+
deletionWindowInDays?: number;
|
|
91
|
+
}
|
|
@@ -0,0 +1,58 @@
|
|
|
1
|
+
import { externalApiUrl } from '@geekmidas/manifest';
|
|
2
|
+
import { type GkmLinkable, ResourceType } from '../Linkable';
|
|
3
|
+
import type { StackType } from '../Stack';
|
|
4
|
+
|
|
5
|
+
/**
|
|
6
|
+
* `ExternalApi` — the infra half of the `external-api` kind.
|
|
7
|
+
*
|
|
8
|
+
* Nothing is provisioned: the API is somebody else's. What this holds is the
|
|
9
|
+
* two facts a function needs to call it on this stage — the URL the
|
|
10
|
+
* declaration names for it, and the credentials the provider issued, kept as
|
|
11
|
+
* an SST secret and set out of band:
|
|
12
|
+
*
|
|
13
|
+
* ```
|
|
14
|
+
* sst secret set PolarCredentials '{"clientId":"…","clientSecret":"…"}' --stage prod
|
|
15
|
+
* ```
|
|
16
|
+
*/
|
|
17
|
+
export class ExternalApi<
|
|
18
|
+
TStage extends string = string,
|
|
19
|
+
TDomain extends string = string,
|
|
20
|
+
> implements GkmLinkable
|
|
21
|
+
{
|
|
22
|
+
readonly _id: string;
|
|
23
|
+
|
|
24
|
+
private readonly url: string;
|
|
25
|
+
|
|
26
|
+
private readonly credentials: sst.Secret;
|
|
27
|
+
|
|
28
|
+
get _type() {
|
|
29
|
+
return ResourceType.ExternalApi;
|
|
30
|
+
}
|
|
31
|
+
|
|
32
|
+
constructor(
|
|
33
|
+
stack: StackType<TStage, TDomain>,
|
|
34
|
+
name: string,
|
|
35
|
+
props: ExternalApiProps,
|
|
36
|
+
) {
|
|
37
|
+
this._id = name;
|
|
38
|
+
// Read at synth, so a stage the declaration has no URL for fails the
|
|
39
|
+
// deploy — with the stage named — rather than the first request.
|
|
40
|
+
this.url = externalApiUrl({ id: name, url: props.url }, stack.stage);
|
|
41
|
+
this.credentials = new sst.Secret(`${name}Credentials`, props.placeholder);
|
|
42
|
+
}
|
|
43
|
+
|
|
44
|
+
provides(): Record<string, $util.Input<string>> {
|
|
45
|
+
return { url: this.url, credentials: this.credentials.value };
|
|
46
|
+
}
|
|
47
|
+
|
|
48
|
+
getSSTLink() {
|
|
49
|
+
return { properties: { ...this.provides() } };
|
|
50
|
+
}
|
|
51
|
+
}
|
|
52
|
+
|
|
53
|
+
export interface ExternalApiProps {
|
|
54
|
+
/** The declaration's `url` — one for every stage, or one per stage name. */
|
|
55
|
+
url: string | Readonly<Record<string, string>>;
|
|
56
|
+
/** A value for the credentials secret until one is set, for a preview stage. */
|
|
57
|
+
placeholder?: string;
|
|
58
|
+
}
|
package/src/sst/aws/Function.ts
CHANGED
|
@@ -1,9 +1,4 @@
|
|
|
1
1
|
import type { EnvValidator, ValidationResult } from '@geekmidas/envkit/sst';
|
|
2
|
-
import {
|
|
3
|
-
type FunctionInfo,
|
|
4
|
-
flattenManifestField,
|
|
5
|
-
type ManifestField,
|
|
6
|
-
} from '@geekmidas/manifest';
|
|
7
2
|
import { type GkmLinkable, ResourceType } from '../Linkable';
|
|
8
3
|
import { LinkedEnvironment } from '../LinkedEnvironment';
|
|
9
4
|
import type { StackType } from '../Stack';
|
|
@@ -66,9 +61,10 @@ export class Function<
|
|
|
66
61
|
super(id, {
|
|
67
62
|
...fnArgs,
|
|
68
63
|
environment: mergedEnvironment,
|
|
69
|
-
//
|
|
70
|
-
//
|
|
71
|
-
link:
|
|
64
|
+
// Resolved from `links` when `envVars` names what it needs; otherwise
|
|
65
|
+
// the `link` it was given — the edges a manifest declared.
|
|
66
|
+
link:
|
|
67
|
+
envVars.length > 0 ? linked.resolveLink(envVars) : (fnArgs.link ?? []),
|
|
72
68
|
runtime: runtime ?? 'nodejs24.x',
|
|
73
69
|
logging: logging ?? { format: 'json' },
|
|
74
70
|
});
|
|
@@ -78,40 +74,15 @@ export class Function<
|
|
|
78
74
|
this.envVars = envVars;
|
|
79
75
|
}
|
|
80
76
|
|
|
77
|
+
/** Its address, for whatever declared an edge to it. */
|
|
78
|
+
provides(): Record<string, $util.Input<string>> {
|
|
79
|
+
return { url: this.url };
|
|
80
|
+
}
|
|
81
|
+
|
|
81
82
|
/** Re-runs validation and returns the result (does not throw). */
|
|
82
83
|
validate(): ValidationResult {
|
|
83
84
|
return this.validator.validate(this.envVars);
|
|
84
85
|
}
|
|
85
|
-
|
|
86
|
-
/**
|
|
87
|
-
* Build one `Function` per entry in a `gkm build` manifest's `functions`
|
|
88
|
-
* field (flat or partitioned). Shared `props` (e.g. `links`) apply to every
|
|
89
|
-
* function.
|
|
90
|
-
*
|
|
91
|
-
* ```ts
|
|
92
|
-
* Function.fromManifest(stack, manifest.functions, { links: [db] });
|
|
93
|
-
* ```
|
|
94
|
-
*/
|
|
95
|
-
static fromManifest<
|
|
96
|
-
TStage extends string = string,
|
|
97
|
-
TDomain extends string = string,
|
|
98
|
-
>(
|
|
99
|
-
stack: StackType<TStage, TDomain>,
|
|
100
|
-
functions: ManifestField<FunctionInfo>,
|
|
101
|
-
props: Omit<FunctionProps, 'handler'> = {},
|
|
102
|
-
): Function<TStage, TDomain>[] {
|
|
103
|
-
return flattenManifestField(functions).map(
|
|
104
|
-
(fn) =>
|
|
105
|
-
new Function(stack, fn.name, {
|
|
106
|
-
...props,
|
|
107
|
-
name: stack.logicalPrefixedName(fn.name),
|
|
108
|
-
handler: fn.handler,
|
|
109
|
-
envVars: fn.environment,
|
|
110
|
-
timeout: fn.timeout ? `${fn.timeout} seconds` : undefined,
|
|
111
|
-
memory: fn.memorySize ? `${fn.memorySize} MB` : undefined,
|
|
112
|
-
}),
|
|
113
|
-
);
|
|
114
|
-
}
|
|
115
86
|
}
|
|
116
87
|
|
|
117
88
|
export interface FunctionProps extends sst.aws.FunctionArgs {
|
|
@@ -0,0 +1,141 @@
|
|
|
1
|
+
// The codec alone — see the note in `Queue.ts`.
|
|
2
|
+
import * as snsUrl from '@geekmidas/events/sns/url';
|
|
3
|
+
import { providedKeyFor } from '@geekmidas/manifest';
|
|
4
|
+
import { type GkmLinkable, ResourceType } from '../Linkable';
|
|
5
|
+
import { regionOfArn } from '../naming';
|
|
6
|
+
import type { StackType } from '../Stack';
|
|
7
|
+
|
|
8
|
+
/**
|
|
9
|
+
* `Inbox` — mail received, as SST links it. It provisions nothing.
|
|
10
|
+
*
|
|
11
|
+
* What receives the mail is the inbox's provider's, created by `gkm deploy`
|
|
12
|
+
* before SST runs, as it is on a compose stage: the SES receipt rule, the
|
|
13
|
+
* bucket the raw messages are stored in, the topic each is announced on, the
|
|
14
|
+
* domain's MX and DKIM records. The deploy hands SST what that made, read
|
|
15
|
+
* from the stage's secrets by the rule every target reads it by, as env:
|
|
16
|
+
*
|
|
17
|
+
* - `<ID>_URL` — where the raw messages are read, with the provider's key;
|
|
18
|
+
* - `<ID>_DOMAIN` — the stage's domain, which mail is addressed to;
|
|
19
|
+
* - `<TOPIC>_PUBLISHER_CONNECTION_STRING` — the topic, whose ARN its
|
|
20
|
+
* subscribers are subscribed to.
|
|
21
|
+
*
|
|
22
|
+
* Each can be passed instead (`fromManifest(…, { Requests: { url, domain,
|
|
23
|
+
* topic } })`), which is what a test does.
|
|
24
|
+
*/
|
|
25
|
+
export class Inbox<
|
|
26
|
+
TStage extends string = string,
|
|
27
|
+
TDomain extends string = string,
|
|
28
|
+
> implements GkmLinkable
|
|
29
|
+
{
|
|
30
|
+
readonly _id: string;
|
|
31
|
+
|
|
32
|
+
/** The ARN of the topic the provider publishes each receipt on. */
|
|
33
|
+
readonly topicArn: string;
|
|
34
|
+
|
|
35
|
+
private readonly url: string;
|
|
36
|
+
|
|
37
|
+
private readonly domain: string;
|
|
38
|
+
|
|
39
|
+
get _type() {
|
|
40
|
+
return ResourceType.Inbox;
|
|
41
|
+
}
|
|
42
|
+
|
|
43
|
+
constructor(
|
|
44
|
+
_stack: StackType<TStage, TDomain>,
|
|
45
|
+
name: string,
|
|
46
|
+
props: InboxProps,
|
|
47
|
+
) {
|
|
48
|
+
this._id = name;
|
|
49
|
+
const env = props.env ?? process.env;
|
|
50
|
+
const read = (given: string | undefined, key: string): string => {
|
|
51
|
+
const value = given ?? env[key];
|
|
52
|
+
if (!value) throw new InboxNotProvisioned(name, key);
|
|
53
|
+
return value;
|
|
54
|
+
};
|
|
55
|
+
|
|
56
|
+
this.url = read(props.url, providedKeyFor(name, 'inbox', 'url'));
|
|
57
|
+
this.domain = read(props.domain, providedKeyFor(name, 'inbox', 'domain'));
|
|
58
|
+
this.topicArn = snsUrl.parse(
|
|
59
|
+
read(
|
|
60
|
+
props.topic,
|
|
61
|
+
providedKeyFor(props.topicId, 'topic', 'publisherConnectionString'),
|
|
62
|
+
),
|
|
63
|
+
).topicArn;
|
|
64
|
+
}
|
|
65
|
+
|
|
66
|
+
provides(): Record<string, $util.Input<string>> {
|
|
67
|
+
return { url: this.url, domain: this.domain };
|
|
68
|
+
}
|
|
69
|
+
|
|
70
|
+
getSSTLink() {
|
|
71
|
+
return { properties: { ...this.provides() } };
|
|
72
|
+
}
|
|
73
|
+
}
|
|
74
|
+
|
|
75
|
+
export interface InboxProps {
|
|
76
|
+
/** The id of the topic the inbox declared — the provider's, by name. */
|
|
77
|
+
topicId: string;
|
|
78
|
+
/** Where the raw messages are read. `<ID>_URL` from the deploy otherwise. */
|
|
79
|
+
url?: string;
|
|
80
|
+
/** The domain mail is addressed to. `<ID>_DOMAIN` from the deploy otherwise. */
|
|
81
|
+
domain?: string;
|
|
82
|
+
/** The topic's `sns://` string. `<TOPIC>_PUBLISHER_CONNECTION_STRING` otherwise. */
|
|
83
|
+
topic?: string;
|
|
84
|
+
/** Where the deploy's values are read; `process.env` by default. */
|
|
85
|
+
env?: Readonly<Record<string, string | undefined>>;
|
|
86
|
+
}
|
|
87
|
+
|
|
88
|
+
/**
|
|
89
|
+
* The topic an inbox declared, as its provider made it: referenced, never
|
|
90
|
+
* created, so SST cannot make a second topic SES never publishes to.
|
|
91
|
+
*
|
|
92
|
+
* Nothing depends on it — only SES publishes to it — so what it provides is
|
|
93
|
+
* there for the declaration's contract, not for any producer.
|
|
94
|
+
*/
|
|
95
|
+
export class InboxTopic implements GkmLinkable {
|
|
96
|
+
readonly _id: string;
|
|
97
|
+
|
|
98
|
+
get _type() {
|
|
99
|
+
return ResourceType.SnsTopic;
|
|
100
|
+
}
|
|
101
|
+
|
|
102
|
+
constructor(
|
|
103
|
+
name: string,
|
|
104
|
+
private readonly inbox: Inbox,
|
|
105
|
+
) {
|
|
106
|
+
this._id = name;
|
|
107
|
+
}
|
|
108
|
+
|
|
109
|
+
get arn(): string {
|
|
110
|
+
return this.inbox.topicArn;
|
|
111
|
+
}
|
|
112
|
+
|
|
113
|
+
provides(): Record<string, $util.Input<string>> {
|
|
114
|
+
return {
|
|
115
|
+
publisherConnectionString: snsUrl.build({
|
|
116
|
+
topicArn: this.arn,
|
|
117
|
+
region: regionOfArn(this.arn),
|
|
118
|
+
}),
|
|
119
|
+
};
|
|
120
|
+
}
|
|
121
|
+
|
|
122
|
+
getSSTLink() {
|
|
123
|
+
return { properties: { arn: this.arn, ...this.provides() } };
|
|
124
|
+
}
|
|
125
|
+
}
|
|
126
|
+
|
|
127
|
+
/** An inbox's value is neither passed nor in the deploy's env. */
|
|
128
|
+
export class InboxNotProvisioned extends Error {
|
|
129
|
+
constructor(
|
|
130
|
+
readonly id: string,
|
|
131
|
+
readonly key: string,
|
|
132
|
+
) {
|
|
133
|
+
super(
|
|
134
|
+
`'${id}' receives mail, and ${key} is not set. Its provider makes it: ` +
|
|
135
|
+
`deploy with \`gkm deploy --target sst\`, which runs the stage's ` +
|
|
136
|
+
`inbox provider (deploy.inbox.<stage> = { provider: 'ses' }) and ` +
|
|
137
|
+
`hands SST what it made — or pass it to fromManifest.`,
|
|
138
|
+
);
|
|
139
|
+
this.name = 'InboxNotProvisioned';
|
|
140
|
+
}
|
|
141
|
+
}
|
|
@@ -39,8 +39,8 @@ export class ObjectStorage<
|
|
|
39
39
|
|
|
40
40
|
/**
|
|
41
41
|
* The values this bucket resolves onto anything that depends on it, keyed by
|
|
42
|
-
* role. `
|
|
43
|
-
* `
|
|
42
|
+
* role. `providedKeyFor` turns a role into the env key the app declared, so
|
|
43
|
+
* `connectionString` here is `UPLOADS_CONNECTION_STRING` there.
|
|
44
44
|
*
|
|
45
45
|
* Composed *here* because only the resource knows its own shape: the name may
|
|
46
46
|
* be supplied through props or generated, and the region is the bucket's, not
|
|
@@ -50,7 +50,7 @@ export class ObjectStorage<
|
|
|
50
50
|
*/
|
|
51
51
|
provides(): Record<string, $util.Input<string>> {
|
|
52
52
|
return {
|
|
53
|
-
|
|
53
|
+
connectionString: $util
|
|
54
54
|
.all([this.name, this.nodes.bucket.region])
|
|
55
55
|
.apply(([bucket, region]) => s3Url.build({ bucket, region })),
|
|
56
56
|
};
|
package/src/sst/aws/Queue.ts
CHANGED
|
@@ -11,7 +11,8 @@ import type { StackType } from '../Stack';
|
|
|
11
11
|
* work queue. Link it to a producer and the runtime resolves `<NAME>_URL`,
|
|
12
12
|
* `<NAME>_ARN`, and a `<NAME>_PUBLISHER_CONNECTION_STRING` (`sqs://?queueUrl=…`)
|
|
13
13
|
* that `@geekmidas/events`'s `Publisher.fromConnectionString` consumes. Its
|
|
14
|
-
*
|
|
14
|
+
* one consumer — the handler the queue was declared with — is subscribed by
|
|
15
|
+
* {@link Queue.consume}.
|
|
15
16
|
*
|
|
16
17
|
* SST's native `Queue` link exposes only `url`, so `getSSTLink` is overridden to
|
|
17
18
|
* also expose `arn` (what the resolver needs). `QueueProps` extends
|
|
@@ -73,6 +74,26 @@ export class Queue<
|
|
|
73
74
|
};
|
|
74
75
|
}
|
|
75
76
|
|
|
77
|
+
/**
|
|
78
|
+
* Subscribe the queue's one consumer: a Lambda running `handler`, linked to
|
|
79
|
+
* what the consumer depends on and to this queue itself.
|
|
80
|
+
*
|
|
81
|
+
* A queue has exactly one consumer, so this is called once per queue — by
|
|
82
|
+
* `fromManifest`, from the handler the build wrote for it.
|
|
83
|
+
*/
|
|
84
|
+
consume(consumer: QueueConsumer) {
|
|
85
|
+
return this.subscribe(
|
|
86
|
+
{
|
|
87
|
+
handler: consumer.handler,
|
|
88
|
+
link: [this, ...(consumer.link ?? [])],
|
|
89
|
+
runtime: 'nodejs24.x',
|
|
90
|
+
...(consumer.vpc ? { vpc: consumer.vpc } : {}),
|
|
91
|
+
...(consumer.timeout ? { timeout: consumer.timeout } : {}),
|
|
92
|
+
},
|
|
93
|
+
consumer.batchSize ? { batch: { size: consumer.batchSize } } : {},
|
|
94
|
+
);
|
|
95
|
+
}
|
|
96
|
+
|
|
76
97
|
override getSSTLink() {
|
|
77
98
|
const link = super.getSSTLink();
|
|
78
99
|
return {
|
|
@@ -82,6 +103,18 @@ export class Queue<
|
|
|
82
103
|
}
|
|
83
104
|
}
|
|
84
105
|
|
|
106
|
+
/** The queue's one consumer, as {@link Queue.consume} subscribes it. */
|
|
107
|
+
export interface QueueConsumer {
|
|
108
|
+
/** The built handler — `apps/api/.gkm/aws/queues/emails.handler`. */
|
|
109
|
+
handler: string;
|
|
110
|
+
/** What the consumer depends on; the queue itself is always linked. */
|
|
111
|
+
link?: unknown[];
|
|
112
|
+
/** The database's network, when the consumer reaches one. */
|
|
113
|
+
vpc?: sst.aws.Vpc;
|
|
114
|
+
timeout?: `${number} seconds` | `${number} minutes`;
|
|
115
|
+
batchSize?: number;
|
|
116
|
+
}
|
|
117
|
+
|
|
85
118
|
export interface QueueProps extends sst.aws.QueueArgs {
|
|
86
119
|
/**
|
|
87
120
|
* The physical queue name, where the auto-generated one will not do.
|