@baseplate-dev/fastify-generators 0.1.1

package/dist/generators/prisma/prisma-utils/templates/embedded-pipes/embedded-one-to-many.ts

@@ -0,0 +1,247 @@
+// @ts-nocheck
+
+import type { ServiceContext } from '%serviceContextImports';
+
+import { notEmpty } from '%tsUtilsImports';
+
+import type { DataPipeOutput } from '../data-pipes.js';
+import type { UpsertPayload } from './embedded-types.js';
+
+import { mergePipeOperations } from '../data-pipes.js';
+
+// Create Helpers
+
+interface OneToManyCreatePipeInput<DataInput> {
+  input: DataInput[] | undefined;
+  transform?: undefined;
+  context?: undefined;
+}
+
+interface OneToManyCreatePipeInputWithTransform<
+  DataInput,
+  UpsertData extends UpsertPayload<unknown, unknown> = {
+    create: DataInput;
+    update: DataInput;
+  },
+> {
+  input: DataInput[] | undefined;
+  transform: (
+    input: DataInput,
+    context: ServiceContext,
+  ) => Promise<DataPipeOutput<UpsertData>> | DataPipeOutput<UpsertData>;
+  context: ServiceContext;
+}
+
+export async function createOneToManyCreateData<
+  DataInput,
+  UpsertData extends UpsertPayload<unknown, unknown> = {
+    create: DataInput;
+    update: DataInput;
+  },
+>({
+  input,
+  context,
+  transform,
+}:
+  | OneToManyCreatePipeInput<DataInput>
+  | OneToManyCreatePipeInputWithTransform<DataInput, UpsertData>): Promise<
+  DataPipeOutput<{ create: UpsertData['create'][] } | undefined>
+> {
+  if (!input) {
+    return { data: undefined, operations: {} };
+  }
+
+  async function transformCreateInput(
+    item: DataInput,
+  ): Promise<DataPipeOutput<UpsertData>> {
+    return transform
+      ? transform(item, context)
+      : ({
+          data: { create: item, update: item },
+        } as DataPipeOutput<UpsertData>);
+  }
+
+  const createOutputs = await Promise.all(
+    input.map(async (item) => {
+      const output = await transformCreateInput(item);
+      return {
+        data: output.data.create,
+        operations: output.operations,
+      };
+    }),
+  );
+
+  return {
+    data: { create: createOutputs.map((output) => output.data) },
+    operations: mergePipeOperations(createOutputs),
+  };
+}
+
+// Upsert Helpers
+
+interface UpsertManyPayload<
+  UpsertData extends UpsertPayload<unknown, unknown>,
+  WhereUniqueInput,
+  IdField extends string | number | symbol,
+  IdType = string,
+> {
+  deleteMany?: Record<IdField, { notIn: IdType[] }>;
+  upsert?: {
+    where: WhereUniqueInput;
+    create: UpsertData['create'];
+    update: UpsertData['update'];
+  }[];
+  create: UpsertData['create'][];
+}
+
+interface OneToManyUpsertPipeInput<
+  DataInput,
+  WhereUniqueInput,
+  IdField extends keyof DataInput,
+> {
+  input: DataInput[] | undefined;
+  idField: IdField;
+  getWhereUnique: (input: DataInput) => WhereUniqueInput | undefined;
+  transform?: undefined;
+  context?: undefined;
+  parentId?: undefined;
+}
+
+interface OneToManyUpsertPipeInputWithTransform<
+  DataInput,
+  WhereUniqueInput,
+  IdField extends keyof DataInput,
+  ParentId = unknown,
+  UpsertData extends UpsertPayload<unknown, unknown> = {
+    create: DataInput;
+    update: DataInput;
+  },
+> {
+  input: DataInput[] | undefined;
+  context: ServiceContext;
+  idField: IdField;
+  getWhereUnique: (input: DataInput) => WhereUniqueInput | undefined;
+  transform: (
+    input: DataInput,
+    context: ServiceContext,
+    updateKey?: WhereUniqueInput,
+    parentId?: ParentId,
+  ) => Promise<DataPipeOutput<UpsertData>> | DataPipeOutput<UpsertData>;
+  parentId?: ParentId;
+}
+
+export async function createOneToManyUpsertData<
+  DataInput,
+  WhereUniqueInput,
+  IdField extends keyof DataInput,
+  ParentId = unknown,
+  UpsertData extends UpsertPayload<unknown, unknown> = {
+    create: DataInput;
+    update: DataInput;
+  },
+>({
+  input,
+  idField,
+  context,
+  getWhereUnique,
+  transform,
+  parentId,
+}:
+  | OneToManyUpsertPipeInput<DataInput, WhereUniqueInput, IdField>
+  | OneToManyUpsertPipeInputWithTransform<
+      DataInput,
+      WhereUniqueInput,
+      IdField,
+      ParentId,
+      UpsertData
+    >): Promise<
+  DataPipeOutput<
+    | UpsertManyPayload<
+        UpsertData,
+        WhereUniqueInput,
+        IdField,
+        Exclude<DataInput[IdField], undefined>
+      >
+    | undefined
+  >
+> {
+  if (!input) {
+    return { data: undefined, operations: {} };
+  }
+
+  async function transformCreateInput(
+    item: DataInput,
+  ): Promise<DataPipeOutput<UpsertData>> {
+    return transform
+      ? transform(item, context, undefined, parentId)
+      : ({
+          data: { create: item, update: item },
+        } as DataPipeOutput<UpsertData>);
+  }
+
+  const createOutputPromise = Promise.all(
+    input
+      .filter(
+        (item) =>
+          item[idField] === undefined || getWhereUnique(item) === undefined,
+      )
+      .map(async (item) => {
+        const output = await transformCreateInput(item);
+        return {
+          data: output.data.create,
+          operations: output.operations,
+        };
+      }),
+  );
+
+  async function transformUpsertInput(
+    item: DataInput,
+  ): Promise<DataPipeOutput<UpsertData>> {
+    return transform
+      ? transform(item, context, getWhereUnique(item), parentId)
+      : ({
+          data: { create: item, update: item },
+        } as DataPipeOutput<UpsertData>);
+  }
+
+  const upsertOutputPromise = Promise.all(
+    input
+      .filter((item) => item[idField] !== undefined && getWhereUnique(item))
+      .map(async (item) => {
+        const output = await transformUpsertInput(item);
+        return {
+          data: {
+            where: getWhereUnique(item) as WhereUniqueInput,
+            create: output.data.create,
+            update: output.data.update,
+          },
+          operations: output.operations,
+        };
+      }),
+  );
+
+  const [upsertOutput, createOutput] = await Promise.all([
+    upsertOutputPromise,
+    createOutputPromise,
+  ]);
+
+  return {
+    data: {
+      deleteMany:
+        idField &&
+        ({
+          [idField]: {
+            notIn: input.map((data) => data[idField]).filter(notEmpty),
+          },
+        } as Record<
+          IdField,
+          {
+            notIn: Exclude<DataInput[IdField], undefined>[];
+          }
+        >),
+      upsert: upsertOutput.map((output) => output.data),
+      create: createOutput.map((output) => output.data),
+    },
+    operations: mergePipeOperations([...upsertOutput, ...createOutput]),
+  };
+}

package/dist/generators/prisma/prisma-utils/templates/embedded-pipes/embedded-one-to-one.ts

@@ -0,0 +1,148 @@
+// @ts-nocheck
+
+import type { ServiceContext } from '%serviceContextImports';
+import type { Prisma } from '@prisma/client';
+
+import type { DataPipeOutput } from '../data-pipes.js';
+import type { UpsertPayload } from './embedded-types.js';
+
+// Create Helpers
+
+interface OneToOneCreatePipeInput<DataInput> {
+  input: DataInput | undefined;
+  transform?: undefined;
+  context?: undefined;
+}
+
+interface OneToOneCreatePipeInputWithTransform<
+  DataInput,
+  UpsertData extends UpsertPayload<unknown, unknown> = {
+    create: DataInput;
+    update: DataInput;
+  },
+> {
+  input: DataInput | undefined;
+  transform: (
+    input: DataInput,
+    context: ServiceContext,
+  ) => Promise<DataPipeOutput<UpsertData>> | DataPipeOutput<UpsertData>;
+  context: ServiceContext;
+}
+
+export async function createOneToOneCreateData<
+  DataInput,
+  UpsertData extends UpsertPayload<unknown, unknown> = {
+    create: DataInput;
+    update: DataInput;
+  },
+>({
+  input,
+  context,
+  transform,
+}:
+  | OneToOneCreatePipeInput<DataInput>
+  | OneToOneCreatePipeInputWithTransform<DataInput, UpsertData>): Promise<
+  DataPipeOutput<{ create: UpsertData['create'] } | undefined>
+> {
+  if (!input) {
+    return { data: undefined, operations: {} };
+  }
+  if (transform) {
+    const transformedData = await Promise.resolve(transform(input, context));
+    return {
+      data: { create: transformedData.data.create },
+      operations: transformedData.operations,
+    };
+  }
+
+  return {
+    data: { create: input },
+  };
+}
+
+// Upsert helpers
+
+interface OneToOneUpsertPipeInput<DataInput> {
+  input: DataInput | null | undefined;
+  transform?: undefined;
+  context?: undefined;
+  getWhereUnique?: undefined;
+  parentId?: undefined;
+  deleteRelation: () => Prisma.PrismaPromise<unknown>;
+}
+
+interface OneToOneUpsertPipeInputWithTransform<
+  DataInput,
+  WhereUniqueInput extends object,
+  ParentId = unknown,
+  UpsertData extends UpsertPayload<unknown, unknown> = {
+    create: DataInput;
+    update: DataInput;
+  },
+> {
+  input: DataInput | null | undefined;
+  transform: (
+    input: DataInput,
+    context: ServiceContext,
+    updateKey?: WhereUniqueInput,
+    parentId?: ParentId,
+  ) => Promise<DataPipeOutput<UpsertData>> | DataPipeOutput<UpsertData>;
+  context: ServiceContext;
+  getWhereUnique: (input: DataInput) => WhereUniqueInput | undefined;
+  parentId?: ParentId;
+  deleteRelation: () => Prisma.PrismaPromise<unknown>;
+}
+
+export async function createOneToOneUpsertData<
+  DataInput,
+  WhereUniqueInput extends object,
+  ParentId,
+  UpsertData extends UpsertPayload<unknown, unknown> = {
+    create: DataInput;
+    update: DataInput;
+  },
+>({
+  input,
+  context,
+  transform,
+  getWhereUnique,
+  parentId,
+  deleteRelation,
+}:
+  | OneToOneUpsertPipeInput<DataInput>
+  | OneToOneUpsertPipeInputWithTransform<
+      DataInput,
+      WhereUniqueInput,
+      ParentId,
+      UpsertData
+    >): Promise<
+  DataPipeOutput<{ upsert: UpsertData } | { delete: true } | undefined>
+> {
+  if (input === null) {
+    return {
+      data: undefined,
+      operations: { beforePrismaPromises: [deleteRelation()] },
+    };
+  }
+  if (input === undefined) {
+    return { data: undefined, operations: {} };
+  }
+  if (transform) {
+    const transformedData = await Promise.resolve(
+      transform(input, context, getWhereUnique(input), parentId),
+    );
+    return {
+      data: { upsert: transformedData.data },
+      operations: transformedData.operations,
+    };
+  }
+
+  return {
+    data: {
+      upsert: {
+        create: input,
+        update: input,
+      } as UpsertData,
+    },
+  };
+}

package/dist/generators/prisma/prisma-utils/templates/embedded-pipes/embedded-types.ts

@@ -0,0 +1,6 @@
+// @ts-nocheck
+
+export interface UpsertPayload<CreateData, UpdateData> {
+  create: CreateData;
+  update: UpdateData;
+}

package/dist/generators/prisma/prisma-utils/templates/prisma-relations.ts

@@ -0,0 +1,24 @@
+// @ts-nocheck
+
+/**
+ * Small helper function to make it easier to use optional relations in Prisma since the
+ * only way to set a Prisma relation to null is to disconnect it.
+ *
+ * See https://github.com/prisma/prisma/issues/5044
+ */
+export function createPrismaDisconnectOrConnectData<UniqueWhere>(
+  data?: { connect: UniqueWhere } | null,
+):
+  | {
+      disconnect?: boolean;
+      connect?: UniqueWhere;
+    }
+  | undefined {
+  if (data === undefined) {
+    return undefined;
+  }
+  if (data === null) {
+    return { disconnect: true };
+  }
+  return data;
+}

package/dist/generators/stripe/fastify-stripe/fastify-stripe.generator.d.ts

@@ -0,0 +1,46 @@
+export declare const fastifyStripeGenerator: import("@baseplate-dev/sync").GeneratorBundleCreator<{
+    placeholder?: string | undefined;
+}, {
+    nodePackages: import("@baseplate-dev/sync").AnyGeneratorTask;
+    configService: import("@baseplate-dev/sync").GeneratorTask<undefined, {
+        provider: import("@baseplate-dev/sync").ProviderType<Omit<import("@baseplate-dev/utils").FieldMap<{
+            configFields: import("@baseplate-dev/utils").MapContainer<string, import("#src/generators/core/config-service/config-service.generator.js").ConfigServiceField>;
+        }>, "getValues">>;
+    }, undefined>;
+    fastifyServerConfig: import("@baseplate-dev/sync").GeneratorTask<undefined, {
+        provider: import("@baseplate-dev/sync").ProviderType<Omit<import("@baseplate-dev/utils").FieldMap<{
+            errorHandlerFunction: import("@baseplate-dev/utils").ScalarContainer<import("@baseplate-dev/core-generators").TsCodeFragment | undefined>;
+            initializerFragments: import("@baseplate-dev/utils").MapContainer<string, import("@baseplate-dev/core-generators").TsCodeFragment>;
+            plugins: import("@baseplate-dev/utils").MapContainer<string, import("#src/generators/core/fastify-server/fastify-server.generator.js").FastifyServerPlugin>;
+            prePluginFragments: import("@baseplate-dev/utils").MapContainer<string, import("@baseplate-dev/core-generators").TsCodeFragment>;
+        }>, "getValues">>;
+    }, undefined>;
+    main: import("@baseplate-dev/sync").GeneratorTask<{
+        fastifyStripeImports: import("@baseplate-dev/sync").ProviderExport<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+            stripe: {};
+            StripeEventHandler: {
+                isTypeOnly: true;
+            };
+            stripeEventService: {};
+        }>>;
+    }, {
+        typescriptFile: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").TypescriptFileProvider>;
+        configServiceImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+            config: {};
+        }>>;
+        errorHandlerServiceImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+            BadRequestError: {};
+            ForbiddenError: {};
+            handleZodRequestValidationError: {};
+            HttpError: {};
+            InternalServerError: {};
+            logError: {};
+            NotFoundError: {};
+            UnauthorizedError: {};
+        }>>;
+        loggerServiceImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+            logger: {};
+        }>>;
+    }, any>;
+}>;
+//# sourceMappingURL=fastify-stripe.generator.d.ts.map

package/dist/generators/stripe/fastify-stripe/fastify-stripe.generator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fastify-stripe.generator.d.ts","sourceRoot":"","sources":["../../../../src/generators/stripe/fastify-stripe/fastify-stripe.generator.ts"],"names":[],"mappings":"AAkCA,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA2FjC,CAAC"}

package/dist/generators/stripe/fastify-stripe/fastify-stripe.generator.js

@@ -0,0 +1,83 @@
+import { createNodePackagesTask, extractPackageVersions, projectScope, tsCodeFragment, tsImportBuilder, typescriptFileProvider, } from '@baseplate-dev/core-generators';
+import { createGenerator, createGeneratorTask, createProviderTask, } from '@baseplate-dev/sync';
+import { z } from 'zod';
+import { FASTIFY_PACKAGES } from '#src/constants/fastify-packages.js';
+import { configServiceImportsProvider, configServiceProvider, } from '#src/generators/core/config-service/config-service.generator.js';
+import { errorHandlerServiceImportsProvider } from '#src/generators/core/error-handler-service/error-handler-service.generator.js';
+import { fastifyServerConfigProvider } from '#src/generators/core/fastify-server/fastify-server.generator.js';
+import { loggerServiceImportsProvider } from '#src/generators/core/logger-service/logger-service.generator.js';
+import { createFastifyStripeImports, fastifyStripeImportsProvider, } from './generated/ts-import-maps.js';
+import { STRIPE_FASTIFY_STRIPE_TS_TEMPLATES } from './generated/ts-templates.js';
+const descriptorSchema = z.object({
+    placeholder: z.string().optional(),
+});
+export const fastifyStripeGenerator = createGenerator({
+    name: 'stripe/fastify-stripe',
+    generatorFileUrl: import.meta.url,
+    descriptorSchema,
+    buildTasks: () => ({
+        nodePackages: createNodePackagesTask({
+            prod: extractPackageVersions(FASTIFY_PACKAGES, [
+                'stripe',
+                'fastify-raw-body',
+            ]),
+        }),
+        configService: createProviderTask(configServiceProvider, (configService) => {
+            configService.configFields.set('STRIPE_SECRET_KEY', {
+                comment: 'Stripe secret API key',
+                validator: 'z.string().min(1)',
+                seedValue: 'STRIPE_SECRET_KEY',
+            });
+            configService.configFields.set('STRIPE_ENDPOINT_SECRET', {
+                comment: 'Stripe webhook endpoint secret',
+                validator: 'z.string().min(1)',
+                seedValue: 'STRIPE_ENDPOINT_SECRET',
+            });
+        }),
+        fastifyServerConfig: createProviderTask(fastifyServerConfigProvider, (fastifyServerConfig) => {
+            fastifyServerConfig.plugins.set('rawBodyPlugin', {
+                plugin: tsCodeFragment('rawBodyPlugin', tsImportBuilder().default('rawBodyPlugin').from('fastify-raw-body')),
+            });
+            fastifyServerConfig.plugins.set('stripeWebhookPlugin', {
+                plugin: tsCodeFragment('stripeWebhookPlugin', tsImportBuilder(['stripeWebhookPlugin']).from('@/src/plugins/stripe-webhook.js')),
+            });
+        }),
+        main: createGeneratorTask({
+            dependencies: {
+                typescriptFile: typescriptFileProvider,
+                configServiceImports: configServiceImportsProvider,
+                errorHandlerServiceImports: errorHandlerServiceImportsProvider,
+                loggerServiceImports: loggerServiceImportsProvider,
+            },
+            exports: {
+                fastifyStripeImports: fastifyStripeImportsProvider.export(projectScope),
+            },
+            run({ typescriptFile, configServiceImports, errorHandlerServiceImports, loggerServiceImports, }) {
+                return {
+                    providers: {
+                        fastifyStripeImports: createFastifyStripeImports('@/src/services'),
+                    },
+                    build: async (builder) => {
+                        await builder.apply(typescriptFile.renderTemplateGroup({
+                            group: STRIPE_FASTIFY_STRIPE_TS_TEMPLATES.pluginsGroup,
+                            baseDirectory: '@/src/plugins',
+                            importMapProviders: {
+                                configServiceImports,
+                                errorHandlerServiceImports,
+                            },
+                        }));
+                        await builder.apply(typescriptFile.renderTemplateGroup({
+                            group: STRIPE_FASTIFY_STRIPE_TS_TEMPLATES.servicesGroup,
+                            baseDirectory: '@/src/services',
+                            importMapProviders: {
+                                configServiceImports,
+                                loggerServiceImports,
+                            },
+                        }));
+                    },
+                };
+            },
+        }),
+    }),
+});
+//# sourceMappingURL=fastify-stripe.generator.js.map

package/dist/generators/stripe/fastify-stripe/fastify-stripe.generator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"fastify-stripe.generator.js","sourceRoot":"","sources":["../../../../src/generators/stripe/fastify-stripe/fastify-stripe.generator.ts"],"names":[],"mappings":"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"}

package/dist/generators/stripe/fastify-stripe/generated/ts-import-maps.d.ts

@@ -0,0 +1,19 @@
+import type { TsImportMapProviderFromSchema } from '@baseplate-dev/core-generators';
+declare const fastifyStripeImportsSchema: {
+    stripe: {};
+    StripeEventHandler: {
+        isTypeOnly: true;
+    };
+    stripeEventService: {};
+};
+type FastifyStripeImportsProvider = TsImportMapProviderFromSchema<typeof fastifyStripeImportsSchema>;
+export declare const fastifyStripeImportsProvider: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+    stripe: {};
+    StripeEventHandler: {
+        isTypeOnly: true;
+    };
+    stripeEventService: {};
+}>>;
+export declare function createFastifyStripeImports(importBase: string): FastifyStripeImportsProvider;
+export {};
+//# sourceMappingURL=ts-import-maps.d.ts.map

package/dist/generators/stripe/fastify-stripe/generated/ts-import-maps.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ts-import-maps.d.ts","sourceRoot":"","sources":["../../../../../src/generators/stripe/fastify-stripe/generated/ts-import-maps.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,6BAA6B,EAAE,MAAM,gCAAgC,CAAC;AASpF,QAAA,MAAM,0BAA0B;;;;;;CAI9B,CAAC;AAEH,KAAK,4BAA4B,GAAG,6BAA6B,CAC/D,OAAO,0BAA0B,CAClC,CAAC;AAEF,eAAO,MAAM,4BAA4B;;;;;;GAGtC,CAAC;AAEJ,wBAAgB,0BAA0B,CACxC,UAAU,EAAE,MAAM,GACjB,4BAA4B,CAU9B"}

package/dist/generators/stripe/fastify-stripe/generated/ts-import-maps.js

@@ -0,0 +1,20 @@
+import { createTsImportMap, createTsImportMapSchema, } from '@baseplate-dev/core-generators';
+import { createReadOnlyProviderType } from '@baseplate-dev/sync';
+import path from 'node:path/posix';
+const fastifyStripeImportsSchema = createTsImportMapSchema({
+    stripe: {},
+    StripeEventHandler: { isTypeOnly: true },
+    stripeEventService: {},
+});
+export const fastifyStripeImportsProvider = createReadOnlyProviderType('fastify-stripe-imports');
+export function createFastifyStripeImports(importBase) {
+    if (!importBase.startsWith('@/')) {
+        throw new Error('importBase must start with @/');
+    }
+    return createTsImportMap(fastifyStripeImportsSchema, {
+        stripe: path.join(importBase, 'stripe.js'),
+        StripeEventHandler: path.join(importBase, 'stripe-events.js'),
+        stripeEventService: path.join(importBase, 'stripe-events.js'),
+    });
+}
+//# sourceMappingURL=ts-import-maps.js.map

package/dist/generators/stripe/fastify-stripe/generated/ts-import-maps.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ts-import-maps.js","sourceRoot":"","sources":["../../../../../src/generators/stripe/fastify-stripe/generated/ts-import-maps.ts"],"names":[],"mappings":"AAEA,OAAO,EACL,iBAAiB,EACjB,uBAAuB,GACxB,MAAM,gCAAgC,CAAC;AACxC,OAAO,EAAE,0BAA0B,EAAE,MAAM,qBAAqB,CAAC;AACjE,OAAO,IAAI,MAAM,iBAAiB,CAAC;AAEnC,MAAM,0BAA0B,GAAG,uBAAuB,CAAC;IACzD,MAAM,EAAE,EAAE;IACV,kBAAkB,EAAE,EAAE,UAAU,EAAE,IAAI,EAAE;IACxC,kBAAkB,EAAE,EAAE;CACvB,CAAC,CAAC;AAMH,MAAM,CAAC,MAAM,4BAA4B,GACvC,0BAA0B,CACxB,wBAAwB,CACzB,CAAC;AAEJ,MAAM,UAAU,0BAA0B,CACxC,UAAkB;IAElB,IAAI,CAAC,UAAU,CAAC,UAAU,CAAC,IAAI,CAAC,EAAE,CAAC;QACjC,MAAM,IAAI,KAAK,CAAC,+BAA+B,CAAC,CAAC;IACnD,CAAC;IAED,OAAO,iBAAiB,CAAC,0BAA0B,EAAE;QACnD,MAAM,EAAE,IAAI,CAAC,IAAI,CAAC,UAAU,EAAE,WAAW,CAAC;QAC1C,kBAAkB,EAAE,IAAI,CAAC,IAAI,CAAC,UAAU,EAAE,kBAAkB,CAAC;QAC7D,kBAAkB,EAAE,IAAI,CAAC,IAAI,CAAC,UAAU,EAAE,kBAAkB,CAAC;KAC9D,CAAC,CAAC;AACL,CAAC"}

package/dist/generators/stripe/fastify-stripe/generated/ts-templates.d.ts

@@ -0,0 +1,45 @@
+export declare const STRIPE_FASTIFY_STRIPE_TS_TEMPLATES: {
+    pluginsGroup: import("@baseplate-dev/core-generators").TsTemplateGroup<{
+        pluginsWebhook: {
+            destination: string;
+            template: import("@baseplate-dev/core-generators").TsTemplateFile<{}, {
+                configServiceImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+                    config: {};
+                }>>;
+                errorHandlerServiceImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+                    BadRequestError: {};
+                    ForbiddenError: {};
+                    handleZodRequestValidationError: {};
+                    HttpError: {};
+                    InternalServerError: {};
+                    logError: {};
+                    NotFoundError: {};
+                    UnauthorizedError: {};
+                }>>;
+            }>;
+        };
+        pluginsWebhookTest: {
+            destination: string;
+            template: import("@baseplate-dev/core-generators").TsTemplateFile<{}, Record<never, import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/sync").Provider>>>;
+        };
+    }>;
+    servicesGroup: import("@baseplate-dev/core-generators").TsTemplateGroup<{
+        service: {
+            destination: string;
+            template: import("@baseplate-dev/core-generators").TsTemplateFile<{}, {
+                configServiceImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+                    config: {};
+                }>>;
+            }>;
+        };
+        serviceEvents: {
+            destination: string;
+            template: import("@baseplate-dev/core-generators").TsTemplateFile<{}, {
+                loggerServiceImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+                    logger: {};
+                }>>;
+            }>;
+        };
+    }>;
+};
+//# sourceMappingURL=ts-templates.d.ts.map

package/dist/generators/stripe/fastify-stripe/generated/ts-templates.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ts-templates.d.ts","sourceRoot":"","sources":["../../../../../src/generators/stripe/fastify-stripe/generated/ts-templates.ts"],"names":[],"mappings":"AAsEA,eAAO,MAAM,kCAAkC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAG9C,CAAC"}