Stripe construct

src/constructs/abstracts/StripeConstruct.ts

@@ -0,0 +1,31 @@
+import type { StripeProvider } from "@lift/providers";
+import type { ConstructInterface } from "@lift/constructs";
+
+export abstract class StripeConstruct<T> implements ConstructInterface {
+    static create<C extends StripeConstruct = StripeConstruct>(
+        this: {
+            new (provider: StripeProvider, id: string, configuration: Record<string, unknown>): C;
+        },
+        provider: StripeProvider,
+        id: string,
+        configuration: Record<string, unknown>
+    ): C {
+        /**
+         * We are passing a `configuration` of type `Record<string, unknown>` to a parameter
+         * of stricter type. This is theoretically invalid.
+         *
+         * In practice however, `configuration` has been validated with the exact JSON schema
+         * of the construct. And that construct has generated the type for `configuration` based
+         * on that schema.
+         * As such, we _know_ that `configuration` has the correct type, it is just not validated
+         * by TypeScript's compiler.
+         */
+        return new this(provider, id, configuration);
+    }
+
+    abstract outputs?(): Record<string, () => Promise<string | undefined>>;
+
+    protected abstract add(configuration: Record<string, unknown>): void | Promise<void>;
+    protected abstract update(resources: T, configuration: Record<string, unknown>): void | Promise<void>;
+    protected abstract destroy(resources: T): void | Promise<void>;
+}

src/constructs/abstracts/index.ts

@@ -1 +1,2 @@
 export { AwsConstruct } from "./AwsConstruct";
+export { StripeConstruct } from "./StripeConstruct";

src/constructs/aws/Queue.ts

@@ -21,7 +21,6 @@ import type { CliOptions } from "../../types/serverless";
 const QUEUE_DEFINITION = {
     type: "object",
     properties: {
-        type: { const: "queue" },
         worker: {
             type: "object",
             properties: {

src/constructs/aws/StaticWebsite.ts

@@ -34,7 +34,6 @@ import ServerlessError from "../../utils/error";
 const STATIC_WEBSITE_DEFINITION = {
     type: "object",
     properties: {
-        type: { const: "static-website" },
         path: { type: "string" },
         domain: {
             anyOf: [

src/constructs/aws/Storage.ts

@@ -9,7 +9,6 @@ import { PolicyStatement } from "../../CloudFormation";
 const STORAGE_DEFINITION = {
     type: "object",
     properties: {
-        type: { const: "storage" },
         archive: { type: "number", minimum: 30 },
         encryption: {
             anyOf: [{ const: "s3" }, { const: "kms" }],
@@ -18,7 +17,6 @@ const STORAGE_DEFINITION = {
     additionalProperties: false,
 } as const;
 const STORAGE_DEFAULTS: Required<FromSchema<typeof STORAGE_DEFINITION>> = {
-    type: "storage",
     archive: 45,
     encryption: "s3",
 };

src/constructs/aws/Vpc.ts

@@ -6,9 +6,7 @@ import type { ConstructInterface } from "@lift/constructs";
 
 const VPC_DEFINITION = {
     type: "object",
-    properties: {
-        type: { const: "vpc" },
-    },
+    properties: {},
     additionalProperties: false,
     required: [],
 } as const;

src/constructs/aws/Webhook.ts

@@ -12,7 +12,6 @@ import ServerlessError from "../../utils/error";
 const WEBHOOK_DEFINITION = {
     type: "object",
     properties: {
-        type: { const: "webhook" },
         authorizer: {
             type: "object",
             properties: {

src/constructs/stripe/Webhook.ts

@@ -0,0 +1,76 @@
+import type { FromSchema } from "json-schema-to-ts";
+import type { Stripe } from "stripe";
+import type { StripeProvider } from "@lift/providers";
+import { StripeConstruct } from "@lift/constructs/abstracts";
+
+const WEBHOOK_DEFINITION = {
+    type: "object",
+    properties: {
+        url: { type: "string" },
+        enabledEvents: { type: "array", items: { type: "string" } },
+    },
+    required: ["url", "enabledEvents"],
+    additionalProperties: false,
+} as const;
+
+type Configuration = FromSchema<typeof WEBHOOK_DEFINITION>;
+
+export class Webhook extends StripeConstruct {
+    public static type = "webhook";
+    public static schema = WEBHOOK_DEFINITION;
+
+    private readonly sdk: Stripe;
+
+    constructor(
+        private readonly provider: StripeProvider,
+        private readonly id: string,
+        private readonly configuration: Configuration
+    ) {
+        super();
+        this.sdk = provider.sdk;
+        const resolvedConfiguration = Object.assign({}, configuration);
+    }
+
+    protected async add(configuration: Configuration): Promise<void> {
+        if (configuration.enabledEvents.every(this.validateEvent)) {
+            const webhook = await this.sdk.webhookEndpoints.create({
+                url: configuration.url,
+                enabled_events: configuration.enabledEvents,
+            });
+            this.provider.referenceNewStripeResources(this.id, webhook.id);
+        }
+    }
+
+    protected async update(resources: string, configuration: Configuration): Promise<void> {
+        const webhookId = this.provider.getStripeResources(this.id);
+        if (typeof webhookId !== "string") {
+            throw new Error("This should not happen");
+        }
+        if (configuration.enabledEvents.every(this.validateEvent)) {
+            await this.sdk.webhookEndpoints.update(webhookId, {
+                url: configuration.url,
+                enabled_events: configuration.enabledEvents,
+            });
+        }
+    }
+
+    protected async destroy(resources: string): Promise<void> {
+        const webhookId = this.provider.getStripeResources(this.id);
+        if (typeof webhookId !== "string") {
+            throw new Error("This should not happen");
+        }
+        await this.sdk.webhookEndpoints.del(webhookId);
+    }
+
+    private validateEvent(event: string): event is Stripe.WebhookEndpointCreateParams.EnabledEvent {
+        return true;
+    }
+
+    outputs(): Record<string, () => Promise<string | undefined>> {
+        return {};
+    }
+
+    variables(): Record<string, unknown> {
+        return {};
+    }
+}

src/constructs/stripe/index.ts

@@ -0,0 +1 @@
+export { Webhook } from "./Webhook";

src/plugin.ts

@@ -139,7 +139,9 @@ class LiftPlugin {
             this.constructsSchema.patternProperties[CONSTRUCT_ID_PATTERN].allOf as unknown as Record<string, unknown>[]
         ).push({
             oneOf: this.getAllConstructClasses().map((Construct) => {
-                return this.defineSchemaWithType(Construct.type, Construct.schema);
+                const constructSchema = this.defineSchemaWithType(Construct.type, Construct.schema);
+
+                return merge(constructSchema, { properties: { provider: { type: "string" } } });
             }),
         });
     }

src/providers/StripeProvider.ts

@@ -6,6 +6,7 @@ import { get, has } from "lodash";
 import { Stripe } from "stripe";
 import type { ConstructInterface, StaticConstructInterface } from "@lift/constructs";
 import type { ProviderInterface } from "@lift/providers";
+import { Webhook } from "@lift/constructs/stripe";
 import type { FromSchema } from "json-schema-to-ts";
 import type { Serverless } from "../types/serverless";
 import ServerlessError from "../utils/error";
@@ -61,9 +62,22 @@ export class StripeProvider implements ProviderInterface {
 
     private config: { apiKey: string; accountId?: string };
     public sdk: Stripe;
+    private state: Record<string, unknown>;
     constructor(private readonly serverless: Serverless, private readonly id: string, profile?: string) {
         this.config = this.resolveConfiguration(profile);
         this.sdk = new Stripe(this.config.apiKey, { apiVersion: "2020-08-27" });
+        this.state = {};
+    }
+
+    public referenceNewStripeResources<T>(constructId: string, resources: T): void {
+        if (this.state[constructId] !== undefined) {
+            throw new ServerlessError("State information were already existing for this construct", "");
+        }
+        this.state[constructId] = resources;
+    }
+
+    public getStripeResources(constructId: string): unknown {
+        return this.state[constructId];
     }
 
     createConstruct(type: string, id: string): ConstructInterface {
@@ -135,3 +149,5 @@ export class StripeProvider implements ProviderInterface {
         };
     }
 }
+
+StripeProvider.registerConstructs(Webhook);

test/fixtures/stripe/serverless.yml

@@ -10,3 +10,11 @@ providers:
         profile: myProfile
     stripeProviderWithoutProfile:
         type: stripe
+
+constructs:
+    monWebhook:
+        type: webhook
+        provider: stripeProviderWithProfile
+        url: test
+        enabledEvents:
+            - payin