@webiny/project-aws 0.0.0-unstable.61c048f412

package/pulumi/extensions/OpenSearch.d.ts

@@ -0,0 +1,17 @@
+import { z } from "zod";
+export declare const OpenSearch: import("@webiny/project/defineExtension/defineExtension").ExtensionComponent<z.ZodObject<{
+    enabled: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+    domainName: z.ZodOptional<z.ZodString>;
+    indexPrefix: z.ZodOptional<z.ZodString>;
+    sharedIndexes: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+}, "strip", z.ZodTypeAny, {
+    enabled?: boolean | undefined;
+    domainName?: string | undefined;
+    indexPrefix?: string | undefined;
+    sharedIndexes?: boolean | undefined;
+}, {
+    enabled?: boolean | undefined;
+    domainName?: string | undefined;
+    indexPrefix?: string | undefined;
+    sharedIndexes?: boolean | undefined;
+}>>;

package/pulumi/extensions/OpenSearch.js

@@ -0,0 +1,17 @@
+import { defineExtension } from "@webiny/project/defineExtension/index.js";
+import { z } from "zod";
+export const OpenSearch = defineExtension({
+  type: "Infra/OpenSearch",
+  tags: {
+    runtimeContext: "project"
+  },
+  description: "Enable and configure Opensearch integration.",
+  paramsSchema: z.object({
+    enabled: z.boolean().describe("Whether to enable OpenSearch.").default(false).optional(),
+    domainName: z.string().describe("The name of the Opensearch domain.").optional(),
+    indexPrefix: z.string().describe("A prefix to be added to all Opensearch indexes.").optional(),
+    sharedIndexes: z.boolean().describe("Whether to use shared indexes across all environments (true) or separate indexes per environment (false).").default(false).optional()
+  })
+});
+
+//# sourceMappingURL=OpenSearch.js.map

package/pulumi/extensions/OpenSearch.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["defineExtension","z","OpenSearch","type","tags","runtimeContext","description","paramsSchema","object","enabled","boolean","describe","default","optional","domainName","string","indexPrefix","sharedIndexes"],"sources":["OpenSearch.ts"],"sourcesContent":["import { defineExtension } from \"@webiny/project/defineExtension/index.js\";\nimport { z } from \"zod\";\n\nexport const OpenSearch = defineExtension({\n    type: \"Infra/OpenSearch\",\n    tags: { runtimeContext: \"project\" },\n    description: \"Enable and configure Opensearch integration.\",\n    paramsSchema: z.object({\n        enabled: z.boolean().describe(\"Whether to enable OpenSearch.\").default(false).optional(),\n        domainName: z.string().describe(\"The name of the Opensearch domain.\").optional(),\n        indexPrefix: z\n            .string()\n            .describe(\"A prefix to be added to all Opensearch indexes.\")\n            .optional(),\n        sharedIndexes: z\n            .boolean()\n            .describe(\n                \"Whether to use shared indexes across all environments (true) or separate indexes per environment (false).\"\n            )\n            .default(false)\n            .optional()\n    })\n});\n"],"mappings":"AAAA,SAASA,eAAe,QAAQ,0CAA0C;AAC1E,SAASC,CAAC,QAAQ,KAAK;AAEvB,OAAO,MAAMC,UAAU,GAAGF,eAAe,CAAC;EACtCG,IAAI,EAAE,kBAAkB;EACxBC,IAAI,EAAE;IAAEC,cAAc,EAAE;EAAU,CAAC;EACnCC,WAAW,EAAE,8CAA8C;EAC3DC,YAAY,EAAEN,CAAC,CAACO,MAAM,CAAC;IACnBC,OAAO,EAAER,CAAC,CAACS,OAAO,CAAC,CAAC,CAACC,QAAQ,CAAC,+BAA+B,CAAC,CAACC,OAAO,CAAC,KAAK,CAAC,CAACC,QAAQ,CAAC,CAAC;IACxFC,UAAU,EAAEb,CAAC,CAACc,MAAM,CAAC,CAAC,CAACJ,QAAQ,CAAC,oCAAoC,CAAC,CAACE,QAAQ,CAAC,CAAC;IAChFG,WAAW,EAAEf,CAAC,CACTc,MAAM,CAAC,CAAC,CACRJ,QAAQ,CAAC,iDAAiD,CAAC,CAC3DE,QAAQ,CAAC,CAAC;IACfI,aAAa,EAAEhB,CAAC,CACXS,OAAO,CAAC,CAAC,CACTC,QAAQ,CACL,2GACJ,CAAC,CACAC,OAAO,CAAC,KAAK,CAAC,CACdC,QAAQ,CAAC;EAClB,CAAC;AACL,CAAC,CAAC","ignoreList":[]}

package/pulumi/extensions/Vpc.d.ts

@@ -0,0 +1,71 @@
+import { z } from "zod";
+export declare const Vpc: import("@webiny/project/defineExtension/defineExtension").ExtensionComponent<z.ZodObject<{
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    useVpcEndpoints: z.ZodOptional<z.ZodBoolean>;
+    useExistingVpc: z.ZodOptional<z.ZodObject<{
+        openSearchDomainVpcConfig: z.ZodOptional<z.ZodObject<{
+            securityGroupIds: z.ZodArray<z.ZodString, "many">;
+            subnetIds: z.ZodArray<z.ZodString, "many">;
+        }, "strip", z.ZodTypeAny, {
+            securityGroupIds: string[];
+            subnetIds: string[];
+        }, {
+            securityGroupIds: string[];
+            subnetIds: string[];
+        }>>;
+        lambdaFunctionsVpcConfig: z.ZodObject<{
+            securityGroupIds: z.ZodArray<z.ZodString, "many">;
+            subnetIds: z.ZodArray<z.ZodString, "many">;
+        }, "strip", z.ZodTypeAny, {
+            securityGroupIds: string[];
+            subnetIds: string[];
+        }, {
+            securityGroupIds: string[];
+            subnetIds: string[];
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        lambdaFunctionsVpcConfig: {
+            securityGroupIds: string[];
+            subnetIds: string[];
+        };
+        openSearchDomainVpcConfig?: {
+            securityGroupIds: string[];
+            subnetIds: string[];
+        } | undefined;
+    }, {
+        lambdaFunctionsVpcConfig: {
+            securityGroupIds: string[];
+            subnetIds: string[];
+        };
+        openSearchDomainVpcConfig?: {
+            securityGroupIds: string[];
+            subnetIds: string[];
+        } | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    enabled: boolean;
+    useVpcEndpoints?: boolean | undefined;
+    useExistingVpc?: {
+        lambdaFunctionsVpcConfig: {
+            securityGroupIds: string[];
+            subnetIds: string[];
+        };
+        openSearchDomainVpcConfig?: {
+            securityGroupIds: string[];
+            subnetIds: string[];
+        } | undefined;
+    } | undefined;
+}, {
+    enabled?: boolean | undefined;
+    useVpcEndpoints?: boolean | undefined;
+    useExistingVpc?: {
+        lambdaFunctionsVpcConfig: {
+            securityGroupIds: string[];
+            subnetIds: string[];
+        };
+        openSearchDomainVpcConfig?: {
+            securityGroupIds: string[];
+            subnetIds: string[];
+        } | undefined;
+    } | undefined;
+}>>;

package/pulumi/extensions/Vpc.js

@@ -0,0 +1,25 @@
+import { defineExtension } from "@webiny/project/defineExtension/index.js";
+import { z } from "zod";
+export const Vpc = defineExtension({
+  type: "Infra/Vpc",
+  tags: {
+    runtimeContext: "project"
+  },
+  description: "Apply VPC settings to AWS resources during deployment.",
+  paramsSchema: z.object({
+    enabled: z.boolean().describe("Whether to enable VPC.").default(false),
+    useVpcEndpoints: z.boolean().optional().describe("Whether to use VPC endpoints for AWS services."),
+    useExistingVpc: z.object({
+      openSearchDomainVpcConfig: z.object({
+        securityGroupIds: z.array(z.string()).describe("The security group IDs for the OpenSearch domain."),
+        subnetIds: z.array(z.string()).describe("The subnet IDs for the OpenSearch domain.")
+      }).optional().describe("VPC configuration for an existing OpenSearch domain."),
+      lambdaFunctionsVpcConfig: z.object({
+        securityGroupIds: z.array(z.string()).describe("The security group IDs for the Lambda functions."),
+        subnetIds: z.array(z.string()).describe("The subnet IDs for the Lambda functions.")
+      }).describe("VPC configuration for Lambda functions.")
+    }).optional().describe("Configuration for using an existing VPC.")
+  })
+});
+
+//# sourceMappingURL=Vpc.js.map

package/pulumi/extensions/Vpc.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["defineExtension","z","Vpc","type","tags","runtimeContext","description","paramsSchema","object","enabled","boolean","describe","default","useVpcEndpoints","optional","useExistingVpc","openSearchDomainVpcConfig","securityGroupIds","array","string","subnetIds","lambdaFunctionsVpcConfig"],"sources":["Vpc.ts"],"sourcesContent":["import { defineExtension } from \"@webiny/project/defineExtension/index.js\";\nimport { z } from \"zod\";\n\nexport const Vpc = defineExtension({\n    type: \"Infra/Vpc\",\n    tags: { runtimeContext: \"project\" },\n    description: \"Apply VPC settings to AWS resources during deployment.\",\n    paramsSchema: z.object({\n        enabled: z.boolean().describe(\"Whether to enable VPC.\").default(false),\n        useVpcEndpoints: z\n            .boolean()\n            .optional()\n            .describe(\"Whether to use VPC endpoints for AWS services.\"),\n        useExistingVpc: z\n            .object({\n                openSearchDomainVpcConfig: z\n                    .object({\n                        securityGroupIds: z\n                            .array(z.string())\n                            .describe(\"The security group IDs for the OpenSearch domain.\"),\n                        subnetIds: z\n                            .array(z.string())\n                            .describe(\"The subnet IDs for the OpenSearch domain.\")\n                    })\n                    .optional()\n                    .describe(\"VPC configuration for an existing OpenSearch domain.\"),\n                lambdaFunctionsVpcConfig: z\n                    .object({\n                        securityGroupIds: z\n                            .array(z.string())\n                            .describe(\"The security group IDs for the Lambda functions.\"),\n                        subnetIds: z\n                            .array(z.string())\n                            .describe(\"The subnet IDs for the Lambda functions.\")\n                    })\n                    .describe(\"VPC configuration for Lambda functions.\")\n            })\n            .optional()\n            .describe(\"Configuration for using an existing VPC.\")\n    })\n});\n"],"mappings":"AAAA,SAASA,eAAe,QAAQ,0CAA0C;AAC1E,SAASC,CAAC,QAAQ,KAAK;AAEvB,OAAO,MAAMC,GAAG,GAAGF,eAAe,CAAC;EAC/BG,IAAI,EAAE,WAAW;EACjBC,IAAI,EAAE;IAAEC,cAAc,EAAE;EAAU,CAAC;EACnCC,WAAW,EAAE,wDAAwD;EACrEC,YAAY,EAAEN,CAAC,CAACO,MAAM,CAAC;IACnBC,OAAO,EAAER,CAAC,CAACS,OAAO,CAAC,CAAC,CAACC,QAAQ,CAAC,wBAAwB,CAAC,CAACC,OAAO,CAAC,KAAK,CAAC;IACtEC,eAAe,EAAEZ,CAAC,CACbS,OAAO,CAAC,CAAC,CACTI,QAAQ,CAAC,CAAC,CACVH,QAAQ,CAAC,gDAAgD,CAAC;IAC/DI,cAAc,EAAEd,CAAC,CACZO,MAAM,CAAC;MACJQ,yBAAyB,EAAEf,CAAC,CACvBO,MAAM,CAAC;QACJS,gBAAgB,EAAEhB,CAAC,CACdiB,KAAK,CAACjB,CAAC,CAACkB,MAAM,CAAC,CAAC,CAAC,CACjBR,QAAQ,CAAC,mDAAmD,CAAC;QAClES,SAAS,EAAEnB,CAAC,CACPiB,KAAK,CAACjB,CAAC,CAACkB,MAAM,CAAC,CAAC,CAAC,CACjBR,QAAQ,CAAC,2CAA2C;MAC7D,CAAC,CAAC,CACDG,QAAQ,CAAC,CAAC,CACVH,QAAQ,CAAC,sDAAsD,CAAC;MACrEU,wBAAwB,EAAEpB,CAAC,CACtBO,MAAM,CAAC;QACJS,gBAAgB,EAAEhB,CAAC,CACdiB,KAAK,CAACjB,CAAC,CAACkB,MAAM,CAAC,CAAC,CAAC,CACjBR,QAAQ,CAAC,kDAAkD,CAAC;QACjES,SAAS,EAAEnB,CAAC,CACPiB,KAAK,CAACjB,CAAC,CAACkB,MAAM,CAAC,CAAC,CAAC,CACjBR,QAAQ,CAAC,0CAA0C;MAC5D,CAAC,CAAC,CACDA,QAAQ,CAAC,yCAAyC;IAC3D,CAAC,CAAC,CACDG,QAAQ,CAAC,CAAC,CACVH,QAAQ,CAAC,0CAA0C;EAC5D,CAAC;AACL,CAAC,CAAC","ignoreList":[]}

package/pulumi/extensions/index.d.ts

@@ -0,0 +1,220 @@
+import { AwsTags } from "./AwsTags.js";
+import { OpenSearch } from "./OpenSearch.js";
+import { Vpc } from "./Vpc.js";
+import { AdminCustomDomains } from "./AdminCustomDomains.js";
+import { BlueGreenDeployments } from "../../pulumi/extensions/BlueGreenDeployments.js";
+export { AwsTags };
+export { Vpc };
+export { OpenSearch };
+export { AdminCustomDomains };
+export { BlueGreenDeployments };
+export declare const definitions: (import("@webiny/project/defineExtension/index.js").ExtensionDefinitionModel<import("zod").ZodObject<{
+    tags: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
+}, "strip", import("zod").ZodTypeAny, {
+    tags: Record<string, string>;
+}, {
+    tags: Record<string, string>;
+}>> | import("@webiny/project/defineExtension/index.js").ExtensionDefinitionModel<import("zod").ZodObject<{
+    enabled: import("zod").ZodDefault<import("zod").ZodBoolean>;
+    useVpcEndpoints: import("zod").ZodOptional<import("zod").ZodBoolean>;
+    useExistingVpc: import("zod").ZodOptional<import("zod").ZodObject<{
+        openSearchDomainVpcConfig: import("zod").ZodOptional<import("zod").ZodObject<{
+            securityGroupIds: import("zod").ZodArray<import("zod").ZodString, "many">;
+            subnetIds: import("zod").ZodArray<import("zod").ZodString, "many">;
+        }, "strip", import("zod").ZodTypeAny, {
+            securityGroupIds: string[];
+            subnetIds: string[];
+        }, {
+            securityGroupIds: string[];
+            subnetIds: string[];
+        }>>;
+        lambdaFunctionsVpcConfig: import("zod").ZodObject<{
+            securityGroupIds: import("zod").ZodArray<import("zod").ZodString, "many">;
+            subnetIds: import("zod").ZodArray<import("zod").ZodString, "many">;
+        }, "strip", import("zod").ZodTypeAny, {
+            securityGroupIds: string[];
+            subnetIds: string[];
+        }, {
+            securityGroupIds: string[];
+            subnetIds: string[];
+        }>;
+    }, "strip", import("zod").ZodTypeAny, {
+        lambdaFunctionsVpcConfig: {
+            securityGroupIds: string[];
+            subnetIds: string[];
+        };
+        openSearchDomainVpcConfig?: {
+            securityGroupIds: string[];
+            subnetIds: string[];
+        } | undefined;
+    }, {
+        lambdaFunctionsVpcConfig: {
+            securityGroupIds: string[];
+            subnetIds: string[];
+        };
+        openSearchDomainVpcConfig?: {
+            securityGroupIds: string[];
+            subnetIds: string[];
+        } | undefined;
+    }>>;
+}, "strip", import("zod").ZodTypeAny, {
+    enabled: boolean;
+    useVpcEndpoints?: boolean | undefined;
+    useExistingVpc?: {
+        lambdaFunctionsVpcConfig: {
+            securityGroupIds: string[];
+            subnetIds: string[];
+        };
+        openSearchDomainVpcConfig?: {
+            securityGroupIds: string[];
+            subnetIds: string[];
+        } | undefined;
+    } | undefined;
+}, {
+    enabled?: boolean | undefined;
+    useVpcEndpoints?: boolean | undefined;
+    useExistingVpc?: {
+        lambdaFunctionsVpcConfig: {
+            securityGroupIds: string[];
+            subnetIds: string[];
+        };
+        openSearchDomainVpcConfig?: {
+            securityGroupIds: string[];
+            subnetIds: string[];
+        } | undefined;
+    } | undefined;
+}>> | import("@webiny/project/defineExtension/index.js").ExtensionDefinitionModel<import("zod").ZodObject<{
+    enabled: import("zod").ZodOptional<import("zod").ZodDefault<import("zod").ZodBoolean>>;
+    domainName: import("zod").ZodOptional<import("zod").ZodString>;
+    indexPrefix: import("zod").ZodOptional<import("zod").ZodString>;
+    sharedIndexes: import("zod").ZodOptional<import("zod").ZodDefault<import("zod").ZodBoolean>>;
+}, "strip", import("zod").ZodTypeAny, {
+    enabled?: boolean | undefined;
+    domainName?: string | undefined;
+    indexPrefix?: string | undefined;
+    sharedIndexes?: boolean | undefined;
+}, {
+    enabled?: boolean | undefined;
+    domainName?: string | undefined;
+    indexPrefix?: string | undefined;
+    sharedIndexes?: boolean | undefined;
+}>> | import("@webiny/project/defineExtension/index.js").ExtensionDefinitionModel<import("zod").ZodObject<{
+    domains: import("zod").ZodArray<import("zod").ZodString, "many">;
+    sslMethod: import("zod").ZodDefault<import("zod").ZodEnum<["sni-only", "vip"]>>;
+    certificateArn: import("zod").ZodString;
+}, "strip", import("zod").ZodTypeAny, {
+    domains: string[];
+    sslMethod: "sni-only" | "vip";
+    certificateArn: string;
+}, {
+    domains: string[];
+    certificateArn: string;
+    sslMethod?: "sni-only" | "vip" | undefined;
+}>> | import("@webiny/project/defineExtension/index.js").ExtensionDefinitionModel<import("zod").ZodObject<{
+    enabled: import("zod").ZodDefault<import("zod").ZodBoolean>;
+    domains: import("zod").ZodObject<{
+        acmCertificateArn: import("zod").ZodString;
+        sslSupportMethod: import("zod").ZodEnum<["sni-only", "vip"]>;
+        domains: import("zod").ZodObject<{
+            api: import("zod").ZodArray<import("zod").ZodString, "atleastone">;
+            admin: import("zod").ZodArray<import("zod").ZodString, "atleastone">;
+            website: import("zod").ZodArray<import("zod").ZodString, "atleastone">;
+            preview: import("zod").ZodArray<import("zod").ZodString, "atleastone">;
+        }, "strip", import("zod").ZodTypeAny, {
+            api: [string, ...string[]];
+            admin: [string, ...string[]];
+            website: [string, ...string[]];
+            preview: [string, ...string[]];
+        }, {
+            api: [string, ...string[]];
+            admin: [string, ...string[]];
+            website: [string, ...string[]];
+            preview: [string, ...string[]];
+        }>;
+    }, "strip", import("zod").ZodTypeAny, {
+        domains: {
+            api: [string, ...string[]];
+            admin: [string, ...string[]];
+            website: [string, ...string[]];
+            preview: [string, ...string[]];
+        };
+        acmCertificateArn: string;
+        sslSupportMethod: "sni-only" | "vip";
+    }, {
+        domains: {
+            api: [string, ...string[]];
+            admin: [string, ...string[]];
+            website: [string, ...string[]];
+            preview: [string, ...string[]];
+        };
+        acmCertificateArn: string;
+        sslSupportMethod: "sni-only" | "vip";
+    }>;
+    deployments: import("zod").ZodTuple<[import("zod").ZodObject<{
+        name: import("zod").ZodString;
+        env: import("zod").ZodString;
+        variant: import("zod").ZodString;
+    }, "strip", import("zod").ZodTypeAny, {
+        name: string;
+        env: string;
+        variant: string;
+    }, {
+        name: string;
+        env: string;
+        variant: string;
+    }>, import("zod").ZodObject<{
+        name: import("zod").ZodString;
+        env: import("zod").ZodString;
+        variant: import("zod").ZodString;
+    }, "strip", import("zod").ZodTypeAny, {
+        name: string;
+        env: string;
+        variant: string;
+    }, {
+        name: string;
+        env: string;
+        variant: string;
+    }>], null>;
+}, "strip", import("zod").ZodTypeAny, {
+    enabled: boolean;
+    domains: {
+        domains: {
+            api: [string, ...string[]];
+            admin: [string, ...string[]];
+            website: [string, ...string[]];
+            preview: [string, ...string[]];
+        };
+        acmCertificateArn: string;
+        sslSupportMethod: "sni-only" | "vip";
+    };
+    deployments: [{
+        name: string;
+        env: string;
+        variant: string;
+    }, {
+        name: string;
+        env: string;
+        variant: string;
+    }];
+}, {
+    domains: {
+        domains: {
+            api: [string, ...string[]];
+            admin: [string, ...string[]];
+            website: [string, ...string[]];
+            preview: [string, ...string[]];
+        };
+        acmCertificateArn: string;
+        sslSupportMethod: "sni-only" | "vip";
+    };
+    deployments: [{
+        name: string;
+        env: string;
+        variant: string;
+    }, {
+        name: string;
+        env: string;
+        variant: string;
+    }];
+    enabled?: boolean | undefined;
+}>>)[];

package/pulumi/extensions/index.js

@@ -0,0 +1,13 @@
+import { AwsTags } from "./AwsTags.js";
+import { OpenSearch } from "./OpenSearch.js";
+import { Vpc } from "./Vpc.js";
+import { AdminCustomDomains } from "./AdminCustomDomains.js";
+import { BlueGreenDeployments } from "./BlueGreenDeployments.js";
+export { AwsTags };
+export { Vpc };
+export { OpenSearch };
+export { AdminCustomDomains };
+export { BlueGreenDeployments };
+export const definitions = [AwsTags.def, Vpc.def, OpenSearch.def, AdminCustomDomains.def, BlueGreenDeployments.def];
+
+//# sourceMappingURL=index.js.map

package/pulumi/extensions/index.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["AwsTags","OpenSearch","Vpc","AdminCustomDomains","BlueGreenDeployments","definitions","def"],"sources":["index.ts"],"sourcesContent":["import { AwsTags } from \"./AwsTags.js\";\nimport { OpenSearch } from \"./OpenSearch.js\";\nimport { Vpc } from \"./Vpc.js\";\nimport { AdminCustomDomains } from \"./AdminCustomDomains.js\";\nimport { BlueGreenDeployments } from \"~/pulumi/extensions/BlueGreenDeployments.js\";\n\nexport { AwsTags };\nexport { Vpc };\nexport { OpenSearch };\nexport { AdminCustomDomains };\nexport { BlueGreenDeployments };\n\nexport const definitions = [\n    AwsTags.def,\n    Vpc.def,\n    OpenSearch.def,\n    AdminCustomDomains.def,\n    BlueGreenDeployments.def\n];\n"],"mappings":"AAAA,SAASA,OAAO;AAChB,SAASC,UAAU;AACnB,SAASC,GAAG;AACZ,SAASC,kBAAkB;AAC3B,SAASC,oBAAoB;AAE7B,SAASJ,OAAO;AAChB,SAASE,GAAG;AACZ,SAASD,UAAU;AACnB,SAASE,kBAAkB;AAC3B,SAASC,oBAAoB;AAE7B,OAAO,MAAMC,WAAW,GAAG,CACvBL,OAAO,CAACM,GAAG,EACXJ,GAAG,CAACI,GAAG,EACPL,UAAU,CAACK,GAAG,EACdH,kBAAkB,CAACG,GAAG,EACtBF,oBAAoB,CAACE,GAAG,CAC3B","ignoreList":[]}

package/pulumi/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./apps/index.js";
+export * from "./utils/index.js";
+export * from "./constants.js";

package/pulumi/index.js

@@ -0,0 +1,5 @@
+export * from "./apps/index.js";
+export * from "./utils/index.js";
+export * from "./constants.js";
+
+//# sourceMappingURL=index.js.map

package/pulumi/index.js.map

@@ -0,0 +1 @@
+{"version":3,"names":[],"sources":["index.ts"],"sourcesContent":["export * from \"./apps/index.js\";\nexport * from \"./utils/index.js\";\nexport * from \"./constants.js\";\n"],"mappings":"AAAA;AACA;AACA","ignoreList":[]}

package/pulumi/types.d.ts

@@ -0,0 +1,44 @@
+import { type IStackOutput } from "@webiny/project";
+export interface IDefaultStackOutput extends IStackOutput {
+    deploymentId: string;
+    region: string;
+    dynamoDbTable: string;
+    migrationLambdaArn: string;
+    iotAuthorizerName: string;
+    apiDomain: string;
+    apiUrl: string;
+    graphqlLambdaRole: string;
+    graphqlLambdaRoleName: string;
+    fileManagerManageLambdaArn: string;
+    fileManagerManageLambdaRole: string;
+    fileManagerManageLambdaRoleName: string;
+    cognitoUserPoolArn: string;
+    cognitoAppClientId: string;
+    cognitoUserPoolId: string;
+    cognitoUserPoolPasswordPolicy: string;
+    websocketApiUrl: string;
+    fileManagerBucketId: string;
+    fileManagerBucketArn: string;
+    primaryDynamodbTableArn: string;
+    primaryDynamodbTableName: string;
+    primaryDynamodbTableHashKey: string;
+    primaryDynamodbTableRangeKey: string;
+    logDynamodbTableArn: string;
+    logDynamodbTableName: string;
+    logDynamodbTableHashKey: string;
+    logDynamodbTableRangeKey: string;
+    eventBusName: string;
+    eventBusArn: string;
+    vpcPublicSubnetIds: string[] | undefined;
+    vpcPrivateSubnetIds: string[] | undefined;
+    vpcSecurityGroupIds: string[] | undefined;
+    opensearchDomainArn: string | undefined;
+    opensearchDomainEndpoint: string | undefined;
+    opensearchDynamodbTableHashKey: string;
+    opensearchDynamodbTableRangeKey: string;
+    opensearchDynamodbTableArn: string | undefined;
+    opensearchDynamodbTableName: string | undefined;
+    appStorage: string;
+    appDomain?: string;
+    deliveryDomain?: string;
+}

package/pulumi/types.js

@@ -0,0 +1,3 @@
+export {};
+
+//# sourceMappingURL=types.js.map

package/pulumi/types.js.map

@@ -0,0 +1 @@
+{"version":3,"names":[],"sources":["types.ts"],"sourcesContent":["import { type IStackOutput } from \"@webiny/project\";\n\n// TODO: split into this per-app stack outputs.\nexport interface IDefaultStackOutput extends IStackOutput {\n    deploymentId: string;\n    region: string;\n    dynamoDbTable: string;\n    migrationLambdaArn: string;\n    iotAuthorizerName: string;\n    apiDomain: string;\n    apiUrl: string;\n    graphqlLambdaRole: string;\n    graphqlLambdaRoleName: string;\n    fileManagerManageLambdaArn: string;\n    fileManagerManageLambdaRole: string;\n    fileManagerManageLambdaRoleName: string;\n    cognitoUserPoolArn: string;\n    cognitoAppClientId: string;\n    cognitoUserPoolId: string;\n    cognitoUserPoolPasswordPolicy: string;\n    websocketApiUrl: string;\n    fileManagerBucketId: string;\n    fileManagerBucketArn: string;\n    primaryDynamodbTableArn: string;\n    primaryDynamodbTableName: string;\n    primaryDynamodbTableHashKey: string;\n    primaryDynamodbTableRangeKey: string;\n    logDynamodbTableArn: string;\n    logDynamodbTableName: string;\n    logDynamodbTableHashKey: string;\n    logDynamodbTableRangeKey: string;\n    eventBusName: string;\n    eventBusArn: string;\n    vpcPublicSubnetIds: string[] | undefined;\n    vpcPrivateSubnetIds: string[] | undefined;\n    vpcSecurityGroupIds: string[] | undefined;\n    opensearchDomainArn: string | undefined;\n    opensearchDomainEndpoint: string | undefined;\n    opensearchDynamodbTableHashKey: string;\n    opensearchDynamodbTableRangeKey: string;\n    opensearchDynamodbTableArn: string | undefined;\n    opensearchDynamodbTableName: string | undefined;\n    appStorage: string;\n    appDomain?: string;\n    deliveryDomain?: string;\n}\n"],"mappings":"","ignoreList":[]}

package/pulumi/utils/addDomainsUrlsOutputs.d.ts

@@ -0,0 +1,18 @@
+import type * as aws from "@pulumi/aws";
+import type { PulumiApp, PulumiAppResource } from "@webiny/pulumi";
+interface AddDomainsUrlsOutputsParams {
+    cloudfrontDistribution: PulumiAppResource<typeof aws.cloudfront.Distribution>;
+    app: PulumiApp;
+    map: {
+        distributionDomain: string;
+        distributionUrl: string;
+        usedDomain: string;
+        usedUrl: string;
+    };
+}
+/**
+ * Based on the provided Cloudfront distribution and map,
+ * adds domain and URL-related values to final stack output.
+ */
+export declare const addDomainsUrlsOutputs: (params: AddDomainsUrlsOutputsParams) => void;
+export {};

package/pulumi/utils/addDomainsUrlsOutputs.js

@@ -0,0 +1,40 @@
+import * as pulumi from "@pulumi/pulumi";
+/**
+ * Based on the provided Cloudfront distribution and map,
+ * adds domain and URL-related values to final stack output.
+ */
+export const addDomainsUrlsOutputs = params => {
+  const {
+    cloudfrontDistribution,
+    app,
+    map
+  } = params;
+
+  // These will always contain the default Cloudfront domain,
+  // no matter if the user provided a custom domain or not.
+  const distributionDomain = cloudfrontDistribution.output.domainName;
+  const distributionUrl = distributionDomain.apply(value => `https://${value}`);
+  app.addOutputs({
+    [map.distributionDomain]: distributionDomain,
+    [map.distributionUrl]: distributionUrl,
+    // These will contain a custom domain if provided,
+    // otherwise again the default Cloudfront domain.
+    [map.usedDomain]: distributionDomain,
+    [map.usedUrl]: distributionUrl
+  });
+
+  // We're adjusting the outputs via the `config.aliases` setter.
+  // At the time of implementing this, could not find a better solution.
+  cloudfrontDistribution.config.aliases(aliases => {
+    const [firstAlias] = aliases || [];
+    if (firstAlias) {
+      app.addOutputs({
+        [map.usedDomain]: pulumi.output(firstAlias),
+        [map.usedUrl]: pulumi.output(`https://${firstAlias}`)
+      });
+    }
+    return aliases;
+  });
+};
+
+//# sourceMappingURL=addDomainsUrlsOutputs.js.map

package/pulumi/utils/addDomainsUrlsOutputs.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["pulumi","addDomainsUrlsOutputs","params","cloudfrontDistribution","app","map","distributionDomain","output","domainName","distributionUrl","apply","value","addOutputs","usedDomain","usedUrl","config","aliases","firstAlias"],"sources":["addDomainsUrlsOutputs.ts"],"sourcesContent":["import * as pulumi from \"@pulumi/pulumi\";\nimport type * as aws from \"@pulumi/aws\";\nimport type { PulumiApp, PulumiAppResource } from \"@webiny/pulumi\";\n\ninterface AddDomainsUrlsOutputsParams {\n    cloudfrontDistribution: PulumiAppResource<typeof aws.cloudfront.Distribution>;\n    app: PulumiApp;\n    map: {\n        distributionDomain: string;\n        distributionUrl: string;\n        usedDomain: string;\n        usedUrl: string;\n    };\n}\n\n/**\n * Based on the provided Cloudfront distribution and map,\n * adds domain and URL-related values to final stack output.\n */\nexport const addDomainsUrlsOutputs = (params: AddDomainsUrlsOutputsParams) => {\n    const { cloudfrontDistribution, app, map } = params;\n\n    // These will always contain the default Cloudfront domain,\n    // no matter if the user provided a custom domain or not.\n    const distributionDomain = cloudfrontDistribution.output.domainName;\n    const distributionUrl = distributionDomain.apply(value => `https://${value}`);\n\n    app.addOutputs({\n        [map.distributionDomain]: distributionDomain,\n        [map.distributionUrl]: distributionUrl,\n\n        // These will contain a custom domain if provided,\n        // otherwise again the default Cloudfront domain.\n        [map.usedDomain]: distributionDomain,\n        [map.usedUrl]: distributionUrl\n    });\n\n    // We're adjusting the outputs via the `config.aliases` setter.\n    // At the time of implementing this, could not find a better solution.\n    cloudfrontDistribution.config.aliases(aliases => {\n        const [firstAlias] = aliases || [];\n        if (firstAlias) {\n            app.addOutputs({\n                [map.usedDomain]: pulumi.output(firstAlias),\n                [map.usedUrl]: pulumi.output(`https://${firstAlias}`)\n            });\n        }\n\n        return aliases;\n    });\n};\n"],"mappings":"AAAA,OAAO,KAAKA,MAAM,MAAM,gBAAgB;AAexC;AACA;AACA;AACA;AACA,OAAO,MAAMC,qBAAqB,GAAIC,MAAmC,IAAK;EAC1E,MAAM;IAAEC,sBAAsB;IAAEC,GAAG;IAAEC;EAAI,CAAC,GAAGH,MAAM;;EAEnD;EACA;EACA,MAAMI,kBAAkB,GAAGH,sBAAsB,CAACI,MAAM,CAACC,UAAU;EACnE,MAAMC,eAAe,GAAGH,kBAAkB,CAACI,KAAK,CAACC,KAAK,IAAI,WAAWA,KAAK,EAAE,CAAC;EAE7EP,GAAG,CAACQ,UAAU,CAAC;IACX,CAACP,GAAG,CAACC,kBAAkB,GAAGA,kBAAkB;IAC5C,CAACD,GAAG,CAACI,eAAe,GAAGA,eAAe;IAEtC;IACA;IACA,CAACJ,GAAG,CAACQ,UAAU,GAAGP,kBAAkB;IACpC,CAACD,GAAG,CAACS,OAAO,GAAGL;EACnB,CAAC,CAAC;;EAEF;EACA;EACAN,sBAAsB,CAACY,MAAM,CAACC,OAAO,CAACA,OAAO,IAAI;IAC7C,MAAM,CAACC,UAAU,CAAC,GAAGD,OAAO,IAAI,EAAE;IAClC,IAAIC,UAAU,EAAE;MACZb,GAAG,CAACQ,UAAU,CAAC;QACX,CAACP,GAAG,CAACQ,UAAU,GAAGb,MAAM,CAACO,MAAM,CAACU,UAAU,CAAC;QAC3C,CAACZ,GAAG,CAACS,OAAO,GAAGd,MAAM,CAACO,MAAM,CAAC,WAAWU,UAAU,EAAE;MACxD,CAAC,CAAC;IACN;IAEA,OAAOD,OAAO;EAClB,CAAC,CAAC;AACN,CAAC","ignoreList":[]}

package/pulumi/utils/addServiceManifestTableItem.d.ts

@@ -0,0 +1,12 @@
+import * as pulumi from "@pulumi/pulumi";
+import type { PulumiApp } from "@webiny/pulumi";
+export interface ServiceManifest {
+    name: string;
+    manifest: Record<string, any>;
+}
+export interface TableDefinition {
+    tableName: pulumi.Output<string>;
+    hashKey: pulumi.Output<string>;
+    rangeKey: pulumi.Output<string | undefined>;
+}
+export declare const addServiceManifestTableItem: (app: PulumiApp, table: TableDefinition, manifest: ServiceManifest) => void;

package/pulumi/utils/addServiceManifestTableItem.js

@@ -0,0 +1,28 @@
+import * as pulumi from "@pulumi/pulumi";
+import * as aws from "@pulumi/aws";
+import { marshall } from "@webiny/aws-sdk/client-dynamodb/index.js";
+export const addServiceManifestTableItem = (app, table, manifest) => {
+  table.rangeKey.apply(res => {
+    new aws.dynamodb.TableItem(manifest.name, {
+      tableName: table.tableName,
+      hashKey: table.hashKey,
+      rangeKey: res,
+      item: pulumi.all(manifest.manifest).apply(res => {
+        return pulumi.interpolate`{
+                "PK": "SERVICE_MANIFEST#${app.name}#${manifest.name}",
+                "SK": "default",
+                "GSI1_PK": "SERVICE_MANIFESTS",
+                "GSI1_SK": "${app.name}#${manifest.name}",
+                "data": {
+                    "name": "${manifest.name}",
+                    "manifest": ${JSON.stringify(res)}
+                }
+            }`;
+      })
+      // We're using the native DynamoDB converter to avoid building those nested objects ourselves.
+      .apply(v => JSON.stringify(marshall(JSON.parse(v))))
+    });
+  });
+};
+
+//# sourceMappingURL=addServiceManifestTableItem.js.map

package/pulumi/utils/addServiceManifestTableItem.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["pulumi","aws","marshall","addServiceManifestTableItem","app","table","manifest","rangeKey","apply","res","dynamodb","TableItem","name","tableName","hashKey","item","all","interpolate","JSON","stringify","v","parse"],"sources":["addServiceManifestTableItem.ts"],"sourcesContent":["import * as pulumi from \"@pulumi/pulumi\";\nimport * as aws from \"@pulumi/aws\";\nimport type { PulumiApp } from \"@webiny/pulumi\";\nimport { marshall } from \"@webiny/aws-sdk/client-dynamodb/index.js\";\n\nexport interface ServiceManifest {\n    name: string;\n    manifest: Record<string, any>;\n}\n\nexport interface TableDefinition {\n    tableName: pulumi.Output<string>;\n    hashKey: pulumi.Output<string>;\n    rangeKey: pulumi.Output<string | undefined>;\n}\n\nexport const addServiceManifestTableItem = (\n    app: PulumiApp,\n    table: TableDefinition,\n    manifest: ServiceManifest\n) => {\n    table.rangeKey.apply(res => {\n        new aws.dynamodb.TableItem(manifest.name, {\n            tableName: table.tableName,\n            hashKey: table.hashKey,\n            rangeKey: res,\n            item: pulumi\n                .all(manifest.manifest)\n                .apply(res => {\n                    return pulumi.interpolate`{\n                \"PK\": \"SERVICE_MANIFEST#${app.name}#${manifest.name}\",\n                \"SK\": \"default\",\n                \"GSI1_PK\": \"SERVICE_MANIFESTS\",\n                \"GSI1_SK\": \"${app.name}#${manifest.name}\",\n                \"data\": {\n                    \"name\": \"${manifest.name}\",\n                    \"manifest\": ${JSON.stringify(res)}\n                }\n            }`;\n                })\n                // We're using the native DynamoDB converter to avoid building those nested objects ourselves.\n                .apply(v => JSON.stringify(marshall(JSON.parse(v))))\n        });\n    });\n};\n"],"mappings":"AAAA,OAAO,KAAKA,MAAM,MAAM,gBAAgB;AACxC,OAAO,KAAKC,GAAG,MAAM,aAAa;AAElC,SAASC,QAAQ,QAAQ,0CAA0C;AAanE,OAAO,MAAMC,2BAA2B,GAAGA,CACvCC,GAAc,EACdC,KAAsB,EACtBC,QAAyB,KACxB;EACDD,KAAK,CAACE,QAAQ,CAACC,KAAK,CAACC,GAAG,IAAI;IACxB,IAAIR,GAAG,CAACS,QAAQ,CAACC,SAAS,CAACL,QAAQ,CAACM,IAAI,EAAE;MACtCC,SAAS,EAAER,KAAK,CAACQ,SAAS;MAC1BC,OAAO,EAAET,KAAK,CAACS,OAAO;MACtBP,QAAQ,EAAEE,GAAG;MACbM,IAAI,EAAEf,MAAM,CACPgB,GAAG,CAACV,QAAQ,CAACA,QAAQ,CAAC,CACtBE,KAAK,CAACC,GAAG,IAAI;QACV,OAAOT,MAAM,CAACiB,WAAW;AAC7C,0CAA0Cb,GAAG,CAACQ,IAAI,IAAIN,QAAQ,CAACM,IAAI;AACnE;AACA;AACA,8BAA8BR,GAAG,CAACQ,IAAI,IAAIN,QAAQ,CAACM,IAAI;AACvD;AACA,+BAA+BN,QAAQ,CAACM,IAAI;AAC5C,kCAAkCM,IAAI,CAACC,SAAS,CAACV,GAAG,CAAC;AACrD;AACA,cAAc;MACE,CAAC;MACD;MAAA,CACCD,KAAK,CAACY,CAAC,IAAIF,IAAI,CAACC,SAAS,CAACjB,QAAQ,CAACgB,IAAI,CAACG,KAAK,CAACD,CAAC,CAAC,CAAC,CAAC;IAC3D,CAAC,CAAC;EACN,CAAC,CAAC;AACN,CAAC","ignoreList":[]}

package/pulumi/utils/crawlDirectory.d.ts

@@ -0,0 +1 @@
+export declare const crawlDirectory: (dir: string, callback: (filePath: string) => void) => void;

package/pulumi/utils/crawlDirectory.js

@@ -0,0 +1,19 @@
+import * as fs from "fs";
+export const crawlDirectory = (dir, callback) => {
+  if (!fs.existsSync(dir)) {
+    return;
+  }
+  const files = fs.readdirSync(dir);
+  for (const file of files) {
+    const filePath = `${dir}/${file}`;
+    const stat = fs.statSync(filePath);
+    if (stat.isDirectory()) {
+      crawlDirectory(filePath, callback);
+    }
+    if (stat.isFile()) {
+      callback(filePath);
+    }
+  }
+};
+
+//# sourceMappingURL=crawlDirectory.js.map

package/pulumi/utils/crawlDirectory.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["fs","crawlDirectory","dir","callback","existsSync","files","readdirSync","file","filePath","stat","statSync","isDirectory","isFile"],"sources":["crawlDirectory.ts"],"sourcesContent":["import * as fs from \"fs\";\n\nexport const crawlDirectory = (dir: string, callback: (filePath: string) => void) => {\n    if (!fs.existsSync(dir)) {\n        return;\n    }\n\n    const files = fs.readdirSync(dir);\n    for (const file of files) {\n        const filePath = `${dir}/${file}`;\n        const stat = fs.statSync(filePath);\n        if (stat.isDirectory()) {\n            crawlDirectory(filePath, callback);\n        }\n        if (stat.isFile()) {\n            callback(filePath);\n        }\n    }\n};\n"],"mappings":"AAAA,OAAO,KAAKA,EAAE,MAAM,IAAI;AAExB,OAAO,MAAMC,cAAc,GAAGA,CAACC,GAAW,EAAEC,QAAoC,KAAK;EACjF,IAAI,CAACH,EAAE,CAACI,UAAU,CAACF,GAAG,CAAC,EAAE;IACrB;EACJ;EAEA,MAAMG,KAAK,GAAGL,EAAE,CAACM,WAAW,CAACJ,GAAG,CAAC;EACjC,KAAK,MAAMK,IAAI,IAAIF,KAAK,EAAE;IACtB,MAAMG,QAAQ,GAAG,GAAGN,GAAG,IAAIK,IAAI,EAAE;IACjC,MAAME,IAAI,GAAGT,EAAE,CAACU,QAAQ,CAACF,QAAQ,CAAC;IAClC,IAAIC,IAAI,CAACE,WAAW,CAAC,CAAC,EAAE;MACpBV,cAAc,CAACO,QAAQ,EAAEL,QAAQ,CAAC;IACtC;IACA,IAAIM,IAAI,CAACG,MAAM,CAAC,CAAC,EAAE;MACfT,QAAQ,CAACK,QAAQ,CAAC;IACtB;EACJ;AACJ,CAAC","ignoreList":[]}

package/pulumi/utils/createAssetArchive.d.ts

@@ -0,0 +1,2 @@
+import * as pulumi from "@pulumi/pulumi";
+export declare const createAssetArchive: (target: string) => pulumi.asset.AssetArchive;

package/pulumi/utils/createAssetArchive.js

@@ -0,0 +1,8 @@
+import * as pulumi from "@pulumi/pulumi";
+export const createAssetArchive = target => {
+  return new pulumi.asset.AssetArchive({
+    ".": new pulumi.asset.FileArchive(target)
+  });
+};
+
+//# sourceMappingURL=createAssetArchive.js.map

package/pulumi/utils/createAssetArchive.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["pulumi","createAssetArchive","target","asset","AssetArchive","FileArchive"],"sources":["createAssetArchive.ts"],"sourcesContent":["import * as pulumi from \"@pulumi/pulumi\";\n\nexport const createAssetArchive = (target: string) => {\n    return new pulumi.asset.AssetArchive({\n        \".\": new pulumi.asset.FileArchive(target)\n    });\n};\n"],"mappings":"AAAA,OAAO,KAAKA,MAAM,MAAM,gBAAgB;AAExC,OAAO,MAAMC,kBAAkB,GAAIC,MAAc,IAAK;EAClD,OAAO,IAAIF,MAAM,CAACG,KAAK,CAACC,YAAY,CAAC;IACjC,GAAG,EAAE,IAAIJ,MAAM,CAACG,KAAK,CAACE,WAAW,CAACH,MAAM;EAC5C,CAAC,CAAC;AACN,CAAC","ignoreList":[]}

package/pulumi/utils/dynamodb.d.ts

@@ -0,0 +1,14 @@
+export interface IDynamoDbConfigAttribute {
+    name: string;
+    type: "S";
+}
+export interface IDynamoDbConfigGlobalSecondaryIndex {
+    name: string;
+    hashKey: string;
+    rangeKey: string;
+    projectionType: "ALL";
+}
+export declare const createDynamoDbGSI: (indexes: string[]) => {
+    withAttributes(original: IDynamoDbConfigAttribute[]): IDynamoDbConfigAttribute[];
+    withGlobalSecondaryIndexes(original: IDynamoDbConfigGlobalSecondaryIndex[]): IDynamoDbConfigGlobalSecondaryIndex[];
+};