@baseplate-dev/fastify-generators 0.1.1

package/dist/generators/core/error-handler-service/error-handler-service.generator.js

@@ -0,0 +1,103 @@
+import { projectScope, tsCodeFragment, TsCodeUtils, tsImportBuilder, typescriptFileProvider, } from '@baseplate-dev/core-generators';
+import { createConfigProviderTask, createGenerator, createGeneratorTask, } from '@baseplate-dev/sync';
+import { z } from 'zod';
+import { configServiceImportsProvider } from '../config-service/config-service.generator.js';
+import { fastifyServerConfigProvider } from '../fastify-server/fastify-server.generator.js';
+import { loggerServiceImportsProvider } from '../logger-service/logger-service.generator.js';
+import { createErrorHandlerServiceImports, errorHandlerServiceImportsProvider, } from './generated/ts-import-maps.js';
+import { CORE_ERROR_HANDLER_SERVICE_TS_TEMPLATES } from './generated/ts-templates.js';
+const descriptorSchema = z.object({});
+export const [configTask, errorHandlerServiceConfigProvider, errorHandlerServiceConfigValuesProvider,] = createConfigProviderTask((t) => ({
+    contextActions: t.map(),
+    loggerActions: t.map(),
+}), {
+    prefix: 'error-handler-service',
+    configScope: projectScope,
+});
+export const errorHandlerServiceGenerator = createGenerator({
+    name: 'core/error-handler-service',
+    generatorFileUrl: import.meta.url,
+    descriptorSchema,
+    buildTasks: () => ({
+        imports: createGeneratorTask({
+            exports: {
+                errorHandlerServiceImports: errorHandlerServiceImportsProvider.export(projectScope),
+            },
+            run() {
+                return {
+                    providers: {
+                        errorHandlerServiceImports: createErrorHandlerServiceImports('@/src'),
+                    },
+                };
+            },
+        }),
+        fastifyPlugin: createGeneratorTask({
+            dependencies: {
+                fastifyServerConfig: fastifyServerConfigProvider,
+                typescriptFile: typescriptFileProvider,
+                configServiceImports: configServiceImportsProvider,
+                errorHandlerServiceImports: errorHandlerServiceImportsProvider,
+            },
+            run({ fastifyServerConfig, typescriptFile, configServiceImports, errorHandlerServiceImports, }) {
+                const errorPluginPath = '@/src/plugins/error-handler.ts';
+                fastifyServerConfig.plugins.set('errorHandlerPlugin', {
+                    plugin: tsCodeFragment('errorHandlerPlugin', tsImportBuilder(['errorHandlerPlugin']).from(errorPluginPath)),
+                    orderPriority: 'EARLY',
+                });
+                fastifyServerConfig.errorHandlerFunction.set(errorHandlerServiceImports.logError.fragment());
+                return {
+                    build: async (builder) => {
+                        await builder.apply(typescriptFile.renderTemplateFile({
+                            template: CORE_ERROR_HANDLER_SERVICE_TS_TEMPLATES.errorHandlerPlugin,
+                            destination: errorPluginPath,
+                            variables: {},
+                            importMapProviders: {
+                                configServiceImports,
+                            },
+                        }));
+                    },
+                };
+            },
+        }),
+        configTask,
+        errorLogger: createGeneratorTask({
+            dependencies: {
+                loggerServiceImports: loggerServiceImportsProvider,
+                typescriptFile: typescriptFileProvider,
+                errorHandlerServiceConfigValues: errorHandlerServiceConfigValuesProvider,
+            },
+            run({ loggerServiceImports, typescriptFile, errorHandlerServiceConfigValues: { contextActions, loggerActions }, }) {
+                return {
+                    build: async (builder) => {
+                        await builder.apply(typescriptFile.renderTemplateFile({
+                            template: CORE_ERROR_HANDLER_SERVICE_TS_TEMPLATES.errorLogger,
+                            destination: '@/src/services/error-logger.ts',
+                            importMapProviders: { loggerServiceImports },
+                            variables: {
+                                TPL_CONTEXT_ACTIONS: TsCodeUtils.mergeFragments(contextActions, '\n\n'),
+                                TPL_LOGGER_ACTIONS: TsCodeUtils.mergeFragments(loggerActions, '\n\n'),
+                            },
+                        }));
+                    },
+                };
+            },
+        }),
+        utils: createGeneratorTask({
+            dependencies: {
+                typescriptFile: typescriptFileProvider,
+            },
+            run({ typescriptFile }) {
+                return {
+                    build: async (builder) => {
+                        await builder.apply(typescriptFile.renderTemplateGroup({
+                            group: CORE_ERROR_HANDLER_SERVICE_TS_TEMPLATES.utilsGroup,
+                            baseDirectory: '@/src/utils',
+                        }));
+                    },
+                };
+            },
+        }),
+    }),
+});
+export { errorHandlerServiceImportsProvider } from './generated/ts-import-maps.js';
+//# sourceMappingURL=error-handler-service.generator.js.map

package/dist/generators/core/error-handler-service/error-handler-service.generator.js.map

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

package/dist/generators/core/error-handler-service/generated/ts-import-maps.d.ts

@@ -0,0 +1,25 @@
+import type { TsImportMapProviderFromSchema } from '@baseplate-dev/core-generators';
+declare const errorHandlerServiceImportsSchema: {
+    BadRequestError: {};
+    ForbiddenError: {};
+    handleZodRequestValidationError: {};
+    HttpError: {};
+    InternalServerError: {};
+    logError: {};
+    NotFoundError: {};
+    UnauthorizedError: {};
+};
+type ErrorHandlerServiceImportsProvider = TsImportMapProviderFromSchema<typeof errorHandlerServiceImportsSchema>;
+export declare const errorHandlerServiceImportsProvider: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+    BadRequestError: {};
+    ForbiddenError: {};
+    handleZodRequestValidationError: {};
+    HttpError: {};
+    InternalServerError: {};
+    logError: {};
+    NotFoundError: {};
+    UnauthorizedError: {};
+}>>;
+export declare function createErrorHandlerServiceImports(importBase: string): ErrorHandlerServiceImportsProvider;
+export {};
+//# sourceMappingURL=ts-import-maps.d.ts.map

package/dist/generators/core/error-handler-service/generated/ts-import-maps.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ts-import-maps.d.ts","sourceRoot":"","sources":["../../../../../src/generators/core/error-handler-service/generated/ts-import-maps.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,6BAA6B,EAAE,MAAM,gCAAgC,CAAC;AASpF,QAAA,MAAM,gCAAgC;;;;;;;;;CASpC,CAAC;AAEH,KAAK,kCAAkC,GAAG,6BAA6B,CACrE,OAAO,gCAAgC,CACxC,CAAC;AAEF,eAAO,MAAM,kCAAkC;;;;;;;;;GAG5C,CAAC;AAEJ,wBAAgB,gCAAgC,CAC9C,UAAU,EAAE,MAAM,GACjB,kCAAkC,CAepC"}

package/dist/generators/core/error-handler-service/generated/ts-import-maps.js

@@ -0,0 +1,30 @@
+import { createTsImportMap, createTsImportMapSchema, } from '@baseplate-dev/core-generators';
+import { createReadOnlyProviderType } from '@baseplate-dev/sync';
+import path from 'node:path/posix';
+const errorHandlerServiceImportsSchema = createTsImportMapSchema({
+    BadRequestError: {},
+    ForbiddenError: {},
+    handleZodRequestValidationError: {},
+    HttpError: {},
+    InternalServerError: {},
+    logError: {},
+    NotFoundError: {},
+    UnauthorizedError: {},
+});
+export const errorHandlerServiceImportsProvider = createReadOnlyProviderType('error-handler-service-imports');
+export function createErrorHandlerServiceImports(importBase) {
+    if (!importBase.startsWith('@/')) {
+        throw new Error('importBase must start with @/');
+    }
+    return createTsImportMap(errorHandlerServiceImportsSchema, {
+        BadRequestError: path.join(importBase, 'utils/http-errors.js'),
+        ForbiddenError: path.join(importBase, 'utils/http-errors.js'),
+        handleZodRequestValidationError: path.join(importBase, 'utils/zod.js'),
+        HttpError: path.join(importBase, 'utils/http-errors.js'),
+        InternalServerError: path.join(importBase, 'utils/http-errors.js'),
+        logError: path.join(importBase, 'services/error-logger.js'),
+        NotFoundError: path.join(importBase, 'utils/http-errors.js'),
+        UnauthorizedError: path.join(importBase, 'utils/http-errors.js'),
+    });
+}
+//# sourceMappingURL=ts-import-maps.js.map

package/dist/generators/core/error-handler-service/generated/ts-import-maps.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ts-import-maps.js","sourceRoot":"","sources":["../../../../../src/generators/core/error-handler-service/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,gCAAgC,GAAG,uBAAuB,CAAC;IAC/D,eAAe,EAAE,EAAE;IACnB,cAAc,EAAE,EAAE;IAClB,+BAA+B,EAAE,EAAE;IACnC,SAAS,EAAE,EAAE;IACb,mBAAmB,EAAE,EAAE;IACvB,QAAQ,EAAE,EAAE;IACZ,aAAa,EAAE,EAAE;IACjB,iBAAiB,EAAE,EAAE;CACtB,CAAC,CAAC;AAMH,MAAM,CAAC,MAAM,kCAAkC,GAC7C,0BAA0B,CACxB,+BAA+B,CAChC,CAAC;AAEJ,MAAM,UAAU,gCAAgC,CAC9C,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,gCAAgC,EAAE;QACzD,eAAe,EAAE,IAAI,CAAC,IAAI,CAAC,UAAU,EAAE,sBAAsB,CAAC;QAC9D,cAAc,EAAE,IAAI,CAAC,IAAI,CAAC,UAAU,EAAE,sBAAsB,CAAC;QAC7D,+BAA+B,EAAE,IAAI,CAAC,IAAI,CAAC,UAAU,EAAE,cAAc,CAAC;QACtE,SAAS,EAAE,IAAI,CAAC,IAAI,CAAC,UAAU,EAAE,sBAAsB,CAAC;QACxD,mBAAmB,EAAE,IAAI,CAAC,IAAI,CAAC,UAAU,EAAE,sBAAsB,CAAC;QAClE,QAAQ,EAAE,IAAI,CAAC,IAAI,CAAC,UAAU,EAAE,0BAA0B,CAAC;QAC3D,aAAa,EAAE,IAAI,CAAC,IAAI,CAAC,UAAU,EAAE,sBAAsB,CAAC;QAC5D,iBAAiB,EAAE,IAAI,CAAC,IAAI,CAAC,UAAU,EAAE,sBAAsB,CAAC;KACjE,CAAC,CAAC;AACL,CAAC"}

package/dist/generators/core/error-handler-service/generated/ts-templates.d.ts

@@ -0,0 +1,26 @@
+export declare const CORE_ERROR_HANDLER_SERVICE_TS_TEMPLATES: {
+    errorHandlerPlugin: import("@baseplate-dev/core-generators").TsTemplateFile<{}, {
+        configServiceImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+            config: {};
+        }>>;
+    }>;
+    errorLogger: import("@baseplate-dev/core-generators").TsTemplateFile<{
+        TPL_CONTEXT_ACTIONS: {};
+        TPL_LOGGER_ACTIONS: {};
+    }, {
+        loggerServiceImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+            logger: {};
+        }>>;
+    }>;
+    utilsGroup: import("@baseplate-dev/core-generators").TsTemplateGroup<{
+        httpErrors: {
+            destination: string;
+            template: import("@baseplate-dev/core-generators").TsTemplateFile<{}, Record<never, import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/sync").Provider>>>;
+        };
+        zod: {
+            destination: string;
+            template: import("@baseplate-dev/core-generators").TsTemplateFile<{}, Record<never, import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/sync").Provider>>>;
+        };
+    }>;
+};
+//# sourceMappingURL=ts-templates.d.ts.map

package/dist/generators/core/error-handler-service/generated/ts-templates.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ts-templates.d.ts","sourceRoot":"","sources":["../../../../../src/generators/core/error-handler-service/generated/ts-templates.ts"],"names":[],"mappings":"AAsDA,eAAO,MAAM,uCAAuC;;;;;;;;;;;;;;;;;;;;;;;;CAInD,CAAC"}

package/dist/generators/core/error-handler-service/generated/ts-templates.js

@@ -0,0 +1,50 @@
+import { createTsTemplateFile, createTsTemplateGroup, } from '@baseplate-dev/core-generators';
+import { configServiceImportsProvider } from '../../config-service/generated/ts-import-maps.js';
+import { loggerServiceImportsProvider } from '../../logger-service/generated/ts-import-maps.js';
+const errorHandlerPlugin = createTsTemplateFile({
+    importMapProviders: { configServiceImports: configServiceImportsProvider },
+    name: 'error-handler-plugin',
+    projectExports: {},
+    source: { path: 'plugins/error-handler.ts' },
+    variables: {},
+});
+const errorLogger = createTsTemplateFile({
+    importMapProviders: { loggerServiceImports: loggerServiceImportsProvider },
+    name: 'error-logger',
+    projectExports: { logError: {} },
+    source: { path: 'services/error-logger.ts' },
+    variables: { TPL_CONTEXT_ACTIONS: {}, TPL_LOGGER_ACTIONS: {} },
+});
+const httpErrors = createTsTemplateFile({
+    group: 'utils',
+    name: 'http-errors',
+    projectExports: {
+        BadRequestError: {},
+        ForbiddenError: {},
+        HttpError: {},
+        InternalServerError: {},
+        NotFoundError: {},
+        UnauthorizedError: {},
+    },
+    source: { path: 'utils/http-errors.ts' },
+    variables: {},
+});
+const zod = createTsTemplateFile({
+    group: 'utils',
+    name: 'zod',
+    projectExports: { handleZodRequestValidationError: {} },
+    source: { path: 'utils/zod.ts' },
+    variables: {},
+});
+const utilsGroup = createTsTemplateGroup({
+    templates: {
+        httpErrors: { destination: 'http-errors.ts', template: httpErrors },
+        zod: { destination: 'zod.ts', template: zod },
+    },
+});
+export const CORE_ERROR_HANDLER_SERVICE_TS_TEMPLATES = {
+    errorHandlerPlugin,
+    errorLogger,
+    utilsGroup,
+};
+//# sourceMappingURL=ts-templates.js.map

package/dist/generators/core/error-handler-service/generated/ts-templates.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ts-templates.js","sourceRoot":"","sources":["../../../../../src/generators/core/error-handler-service/generated/ts-templates.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,oBAAoB,EACpB,qBAAqB,GACtB,MAAM,gCAAgC,CAAC;AAExC,OAAO,EAAE,4BAA4B,EAAE,MAAM,kDAAkD,CAAC;AAChG,OAAO,EAAE,4BAA4B,EAAE,MAAM,kDAAkD,CAAC;AAEhG,MAAM,kBAAkB,GAAG,oBAAoB,CAAC;IAC9C,kBAAkB,EAAE,EAAE,oBAAoB,EAAE,4BAA4B,EAAE;IAC1E,IAAI,EAAE,sBAAsB;IAC5B,cAAc,EAAE,EAAE;IAClB,MAAM,EAAE,EAAE,IAAI,EAAE,0BAA0B,EAAE;IAC5C,SAAS,EAAE,EAAE;CACd,CAAC,CAAC;AAEH,MAAM,WAAW,GAAG,oBAAoB,CAAC;IACvC,kBAAkB,EAAE,EAAE,oBAAoB,EAAE,4BAA4B,EAAE;IAC1E,IAAI,EAAE,cAAc;IACpB,cAAc,EAAE,EAAE,QAAQ,EAAE,EAAE,EAAE;IAChC,MAAM,EAAE,EAAE,IAAI,EAAE,0BAA0B,EAAE;IAC5C,SAAS,EAAE,EAAE,mBAAmB,EAAE,EAAE,EAAE,kBAAkB,EAAE,EAAE,EAAE;CAC/D,CAAC,CAAC;AAEH,MAAM,UAAU,GAAG,oBAAoB,CAAC;IACtC,KAAK,EAAE,OAAO;IACd,IAAI,EAAE,aAAa;IACnB,cAAc,EAAE;QACd,eAAe,EAAE,EAAE;QACnB,cAAc,EAAE,EAAE;QAClB,SAAS,EAAE,EAAE;QACb,mBAAmB,EAAE,EAAE;QACvB,aAAa,EAAE,EAAE;QACjB,iBAAiB,EAAE,EAAE;KACtB;IACD,MAAM,EAAE,EAAE,IAAI,EAAE,sBAAsB,EAAE;IACxC,SAAS,EAAE,EAAE;CACd,CAAC,CAAC;AAEH,MAAM,GAAG,GAAG,oBAAoB,CAAC;IAC/B,KAAK,EAAE,OAAO;IACd,IAAI,EAAE,KAAK;IACX,cAAc,EAAE,EAAE,+BAA+B,EAAE,EAAE,EAAE;IACvD,MAAM,EAAE,EAAE,IAAI,EAAE,cAAc,EAAE;IAChC,SAAS,EAAE,EAAE;CACd,CAAC,CAAC;AAEH,MAAM,UAAU,GAAG,qBAAqB,CAAC;IACvC,SAAS,EAAE;QACT,UAAU,EAAE,EAAE,WAAW,EAAE,gBAAgB,EAAE,QAAQ,EAAE,UAAU,EAAE;QACnE,GAAG,EAAE,EAAE,WAAW,EAAE,QAAQ,EAAE,QAAQ,EAAE,GAAG,EAAE;KAC9C;CACF,CAAC,CAAC;AAEH,MAAM,CAAC,MAAM,uCAAuC,GAAG;IACrD,kBAAkB;IAClB,WAAW;IACX,UAAU;CACX,CAAC"}

package/dist/generators/core/error-handler-service/templates/plugins/error-handler.ts

@@ -0,0 +1,52 @@
+// @ts-nocheck
+
+import { config } from '%configServiceImports';
+import fp from 'fastify-plugin';
+
+import { logError } from '../services/error-logger.js';
+import { HttpError, NotFoundError } from '../utils/http-errors.js';
+
+const IS_DEVELOPMENT = config.APP_ENVIRONMENT === 'development';
+
+/**
+ * Handles errors from Fastify route handlers, sending the correct code
+ * if an HttpError was thrown.
+ */
+export const errorHandlerPlugin = fp((fastify, opts, done) => {
+  fastify.setNotFoundHandler((req) => {
+    throw new NotFoundError(`${req.method} ${req.url} not found`);
+  });
+
+  fastify.setErrorHandler(async (error, request, reply) => {
+    logError(error);
+
+    if (error instanceof HttpError) {
+      await reply.code(error.statusCode).send({
+        ...error.extraData,
+        message: error.message,
+        code: error.code,
+        statusCode: error.statusCode,
+        reqId: request.id,
+      });
+    } else if (error.statusCode && error.statusCode < 500) {
+      await reply.code(error.statusCode).send({
+        message: error.message,
+        code: error.code,
+        statusCode: error.statusCode,
+        reqId: request.id,
+      });
+    } else {
+      await reply.code(500).send({
+        message: 'Internal server error',
+        code: 'INTERNAL_SERVER_ERROR',
+        statusCode: error.statusCode,
+        reqId: request.id,
+        originalError: IS_DEVELOPMENT
+          ? { message: error.message, stack: error.stack }
+          : undefined,
+      });
+    }
+  });
+
+  done();
+});

package/dist/generators/core/error-handler-service/templates/services/error-logger.ts

@@ -0,0 +1,28 @@
+// @ts-nocheck
+
+import { logger } from '%loggerServiceImports';
+
+interface ErrorContext extends Record<string, unknown> {
+  errorId?: string;
+}
+
+/**
+ * Logs error to the appropriate receivers.
+ *
+ * @param err Error object
+ * @param additionalContext Additional context to be logged
+ */
+export function logError(
+  error: unknown,
+  additionalContext?: Record<string, unknown>,
+): string | undefined {
+  const context: ErrorContext = { ...additionalContext };
+
+  TPL_CONTEXT_ACTIONS;
+
+  TPL_LOGGER_ACTIONS;
+
+  logger.error({ err: error, ...context });
+
+  return context.errorId;
+}

package/dist/generators/core/error-handler-service/templates/utils/http-errors.ts

@@ -0,0 +1,62 @@
+// @ts-nocheck
+
+export class HttpError extends Error {
+  constructor(
+    message: string,
+    public code?: string,
+    public extraData?: Record<string, unknown>,
+    public statusCode = 500,
+  ) {
+    super(message);
+  }
+}
+
+export class BadRequestError extends HttpError {
+  constructor(
+    message: string,
+    code = 'BAD_REQUEST',
+    extraData?: Record<string, unknown>,
+  ) {
+    super(message, code, extraData, 400);
+  }
+}
+
+export class UnauthorizedError extends HttpError {
+  constructor(
+    message: string,
+    code = 'UNAUTHORIZED',
+    extraData?: Record<string, unknown>,
+  ) {
+    super(message, code, extraData, 401);
+  }
+}
+
+export class ForbiddenError extends HttpError {
+  constructor(
+    message: string,
+    code = 'FORBIDDEN',
+    extraData?: Record<string, unknown>,
+  ) {
+    super(message, code, extraData, 403);
+  }
+}
+
+export class NotFoundError extends HttpError {
+  constructor(
+    message: string,
+    code = 'NOT_FOUND',
+    extraData?: Record<string, unknown>,
+  ) {
+    super(message, code, extraData, 404);
+  }
+}
+
+export class InternalServerError extends HttpError {
+  constructor(
+    message: string,
+    code = 'INTERNAL_SERVER_ERROR',
+    extraData?: Record<string, unknown>,
+  ) {
+    super(message, code, extraData, 500);
+  }
+}

package/dist/generators/core/error-handler-service/templates/utils/zod.ts

@@ -0,0 +1,30 @@
+// @ts-nocheck
+
+import { ZodError } from 'zod';
+
+import { BadRequestError } from './http-errors.js';
+
+/**
+ * Handles errors that occur during Zod request validation.
+ *
+ * If the provided error is an instance of `ZodError`, it formats the error details
+ * and throws a `BadRequestError` with a `ZOD_VALIDATION_ERROR` code and the formatted errors.
+ * If the error is not a `ZodError`, it is re-thrown as-is.
+ *
+ * @param {unknown} error - The error to handle. Can be any type, but typically expected
+ * to be a `ZodError` when triggered by Zod validation failures.
+ * @throws {BadRequestError} If the error is a `ZodError`, this throws a `BadRequestError`
+ * with the formatted validation errors.
+ * @throws {unknown} If the error is not a `ZodError`, it is re-thrown as-is.
+ * @returns {never} This function does not return as it always throws an error.
+ */
+export const handleZodRequestValidationError = (error: unknown): never => {
+  if (error instanceof ZodError) {
+    throw new BadRequestError('Validation failed', 'ZOD_VALIDATION_ERROR', {
+      errors: error.errors,
+    });
+  }
+
+  // Re-throw non-Zod errors
+  throw error;
+};

package/dist/generators/core/fastify/fastify.generator.d.ts

@@ -0,0 +1,90 @@
+import type { InferFieldMapSchemaFromBuilder } from '@baseplate-dev/utils';
+export type FastifyNodeFlagUseCase = 'dev-env' | 'instrument';
+export interface FastifyNodeFlag {
+    flag: string;
+    /**
+     * The type of flag that is used
+     *
+     * 'dev-env': For setting up environment variables in dev
+     * 'instrument': For instrumenting the code
+     */
+    useCase: FastifyNodeFlagUseCase;
+    targetEnvironment: 'dev' | 'prod';
+}
+export interface FastifyGeneratorConfig {
+    /**
+     * Command to pipe the dev output into, e.g. pino-pretty
+     */
+    devOutputFormatter?: string;
+    nodeFlags: FastifyNodeFlag[];
+}
+declare const fastifyConfigSchema: (t: import("@baseplate-dev/utils").FieldMapSchemaBuilder) => {
+    /**
+     * Command to pipe the dev output into, e.g. pino-pretty
+     */
+    devOutputFormatter: import("@baseplate-dev/utils").ScalarContainer<string | undefined>;
+    /**
+     * Flags to pass to the node command when running
+     */
+    nodeFlags: import("@baseplate-dev/utils").MapContainer<string, FastifyNodeFlag>;
+};
+export type FastifyProvider = InferFieldMapSchemaFromBuilder<typeof fastifyConfigSchema>;
+export declare const fastifyProvider: import("@baseplate-dev/sync").ProviderType<{
+    /**
+     * Command to pipe the dev output into, e.g. pino-pretty
+     */
+    devOutputFormatter: import("@baseplate-dev/utils").ScalarContainer<string | undefined>;
+    /**
+     * Flags to pass to the node command when running
+     */
+    nodeFlags: import("@baseplate-dev/utils").MapContainer<string, FastifyNodeFlag>;
+}>;
+export interface FastifyOutputProvider {
+    getNodeFlags(): FastifyNodeFlag[];
+    getNodeFlagsDev(useCase?: FastifyNodeFlagUseCase): string[];
+    getNodeFlagsProd(useCase?: FastifyNodeFlagUseCase): string[];
+    getDevOutputFormatter(): string | undefined;
+}
+export declare const fastifyOutputProvider: import("@baseplate-dev/sync").ProviderType<FastifyOutputProvider>;
+export declare const fastifyGenerator: import("@baseplate-dev/sync").GeneratorBundleCreator<{
+    placeholder?: string | undefined;
+}, {
+    nodeSetup: import("@baseplate-dev/sync").GeneratorTask<any, {
+        nodeConfig: import("@baseplate-dev/sync").ProviderType<Omit<import("@baseplate-dev/utils").FieldMap<{
+            isEsm: import("@baseplate-dev/utils").ScalarContainer<boolean>;
+        }>, "getValues">>;
+    }, any>;
+    fastifyTypescript: import("@baseplate-dev/sync").GeneratorTask<undefined, {
+        typescriptSetup: import("@baseplate-dev/sync").ProviderType<Omit<import("@baseplate-dev/utils").FieldMap<{
+            compilerOptions: import("@baseplate-dev/utils").ScalarContainer<import("@baseplate-dev/core-generators").TypescriptCompilerOptions>;
+            include: import("@baseplate-dev/utils").ArrayContainer<string>;
+            exclude: import("@baseplate-dev/utils").ArrayContainer<string>;
+            references: import("@baseplate-dev/utils").ArrayContainer<import("@baseplate-dev/core-generators").TypescriptConfigReference>;
+            extraSections: import("@baseplate-dev/utils").ArrayContainer<Record<string, unknown>>;
+        }>, "getValues">>;
+    }, undefined>;
+    node: import("@baseplate-dev/sync").AnyGeneratorTask;
+    gitIgnore: import("@baseplate-dev/sync").GeneratorTask<undefined, {
+        provider: import("@baseplate-dev/sync").ProviderType<Omit<import("@baseplate-dev/utils").FieldMap<{
+            exclusions: import("@baseplate-dev/utils").MapContainer<string, string[]>;
+        }>, "getValues">>;
+    }, undefined>;
+    main: import("@baseplate-dev/sync").GeneratorTask<{
+        fastify: import("@baseplate-dev/sync").ProviderExport<{
+            /**
+             * Command to pipe the dev output into, e.g. pino-pretty
+             */
+            devOutputFormatter: import("@baseplate-dev/utils").ScalarContainer<string | undefined>;
+            /**
+             * Flags to pass to the node command when running
+             */
+            nodeFlags: import("@baseplate-dev/utils").MapContainer<string, FastifyNodeFlag>;
+        }>;
+    }, {
+        node: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").NodeProvider>;
+    }, {
+        fastifyOutput: import("@baseplate-dev/sync").ProviderExport<FastifyOutputProvider>;
+    }>;
+}>;
+export {};
+//# sourceMappingURL=fastify.generator.d.ts.map

package/dist/generators/core/fastify/fastify.generator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fastify.generator.d.ts","sourceRoot":"","sources":["../../../../src/generators/core/fastify/fastify.generator.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,8BAA8B,EAAE,MAAM,sBAAsB,CAAC;AA8B3E,MAAM,MAAM,sBAAsB,GAAG,SAAS,GAAG,YAAY,CAAC;AAE9D,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,MAAM,CAAC;IACb;;;;;OAKG;IACH,OAAO,EAAE,sBAAsB,CAAC;IAChC,iBAAiB,EAAE,KAAK,GAAG,MAAM,CAAC;CACnC;AAED,MAAM,WAAW,sBAAsB;IACrC;;OAEG;IACH,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B,SAAS,EAAE,eAAe,EAAE,CAAC;CAC9B;AAED,QAAA,MAAM,mBAAmB;IACvB;;OAEG;;IAEH;;OAEG;;CAEF,CAAC;AAEJ,MAAM,MAAM,eAAe,GAAG,8BAA8B,CAC1D,OAAO,mBAAmB,CAC3B,CAAC;AAEF,eAAO,MAAM,eAAe;IAd1B;;OAEG;;IAEH;;OAEG;;EAQwE,CAAC;AAE9E,MAAM,WAAW,qBAAqB;IACpC,YAAY,IAAI,eAAe,EAAE,CAAC;IAClC,eAAe,CAAC,OAAO,CAAC,EAAE,sBAAsB,GAAG,MAAM,EAAE,CAAC;IAC5D,gBAAgB,CAAC,OAAO,CAAC,EAAE,sBAAsB,GAAG,MAAM,EAAE,CAAC;IAC7D,qBAAqB,IAAI,MAAM,GAAG,SAAS,CAAC;CAC7C;AAED,eAAO,MAAM,qBAAqB,mEACmC,CAAC;AAEtE,eAAO,MAAM,gBAAgB;;;;;0BAP6B,sBAC1C;;;;;oCAgDQ,sBAAsB;4BAGzB,sBACD;4BAEF,sBACC;+BACsB,sBAAsB;kCAEX,sBAAsB;;;;;;+BA9HtD,sBACA;;;;;YA+ClB;;eAEG;;YAEH;;eAEG;;;;;;;;EAyIH,CAAC"}

package/dist/generators/core/fastify/fastify.generator.js

@@ -0,0 +1,123 @@
+import { createNodeTask, extractPackageVersions, nodeConfigProvider, nodeGitIgnoreProvider, nodeProvider, projectScope, } from '@baseplate-dev/core-generators';
+import { createConfigFieldMap, createGenerator, createGeneratorTask, createProviderTask, createProviderType, createReadOnlyProviderType, } from '@baseplate-dev/sync';
+import { createFieldMapSchemaBuilder } from '@baseplate-dev/utils';
+import { sortBy } from 'es-toolkit';
+import { z } from 'zod';
+import { FASTIFY_PACKAGES } from '#src/constants/fastify-packages.js';
+import { fastifyTypescriptTask } from './setup-fastify-typescript.js';
+const descriptorSchema = z.object({
+    placeholder: z.string().optional(),
+});
+const fastifyConfigSchema = createFieldMapSchemaBuilder((t) => ({
+    /**
+     * Command to pipe the dev output into, e.g. pino-pretty
+     */
+    devOutputFormatter: t.scalar(),
+    /**
+     * Flags to pass to the node command when running
+     */
+    nodeFlags: t.map(),
+}));
+export const fastifyProvider = createProviderType('fastify');
+export const fastifyOutputProvider = createReadOnlyProviderType('fastify-output');
+export const fastifyGenerator = createGenerator({
+    name: 'core/fastify',
+    generatorFileUrl: import.meta.url,
+    descriptorSchema,
+    buildTasks: () => ({
+        nodeSetup: createGeneratorTask({
+            dependencies: {
+                nodeConfig: nodeConfigProvider,
+            },
+            run({ nodeConfig }) {
+                nodeConfig.isEsm.set(false);
+                return {};
+            },
+        }),
+        fastifyTypescript: fastifyTypescriptTask,
+        node: createNodeTask((node) => {
+            node.packages.addDevPackages(extractPackageVersions(FASTIFY_PACKAGES, [
+                'tsc-alias',
+                'tsx',
+                '@types/node',
+            ]));
+            node.extraProperties.merge({
+                main: 'dist/index.js',
+                files: ['dist/**/*', 'package.json', 'README.md'],
+            });
+        }),
+        gitIgnore: createProviderTask(nodeGitIgnoreProvider, (nodeGitIgnore) => {
+            nodeGitIgnore.exclusions.set('fastify', ['/dist']);
+        }),
+        main: createGeneratorTask({
+            dependencies: {
+                node: nodeProvider,
+            },
+            exports: {
+                fastify: fastifyProvider.export(projectScope),
+            },
+            outputs: {
+                fastifyOutput: fastifyOutputProvider.export(projectScope),
+            },
+            run({ node }) {
+                const fastifyConfig = createConfigFieldMap(fastifyConfigSchema);
+                return {
+                    providers: {
+                        fastify: fastifyConfig,
+                    },
+                    build() {
+                        // add scripts
+                        const { devOutputFormatter, nodeFlags } = fastifyConfig.getValues();
+                        const USE_CASE_ORDER = {
+                            'dev-env': 0,
+                            instrument: 1,
+                        };
+                        const sortedNodeFlags = sortBy([...nodeFlags.entries()], 
+                        // Sort by use case, then by name
+                        [([, flag]) => USE_CASE_ORDER[flag.useCase], ([name]) => name]).map(([, flag]) => flag);
+                        const outputFormatter = devOutputFormatter
+                            ? `| ${devOutputFormatter}`
+                            : '';
+                        const devCommand = [
+                            'tsx watch --clear-screen=false',
+                            ...sortedNodeFlags
+                                .filter((f) => f.targetEnvironment === 'dev')
+                                .map((f) => f.flag),
+                            'src/index.ts',
+                            outputFormatter,
+                        ]
+                            .filter(Boolean)
+                            .join(' ');
+                        const startCommand = [
+                            'node',
+                            ...sortedNodeFlags
+                                .filter((f) => f.targetEnvironment === 'prod')
+                                .map((f) => f.flag),
+                            'dist/index.js',
+                        ].join(' ');
+                        node.scripts.mergeObj({
+                            build: 'tsc && tsc-alias',
+                            start: startCommand,
+                            dev: devCommand,
+                        });
+                        return {
+                            fastifyOutput: {
+                                getNodeFlags: () => sortedNodeFlags,
+                                getNodeFlagsDev: (useCase) => sortedNodeFlags
+                                    .filter((f) => f.targetEnvironment === 'dev' &&
+                                    (!useCase || f.useCase === useCase))
+                                    .map((f) => f.flag),
+                                getNodeFlagsProd: (useCase) => sortedNodeFlags
+                                    .filter((f) => f.targetEnvironment === 'prod' &&
+                                    (!useCase || f.useCase === useCase))
+                                    .map((f) => f.flag),
+                                getDevOutputFormatter: () => devOutputFormatter,
+                            },
+                        };
+                    },
+                };
+            },
+        }),
+    }),
+});
+//# sourceMappingURL=fastify.generator.js.map