feat: Support UI and backend of new custom auth plugin

.changeset/all-goats-hammer.md

@@ -0,0 +1,5 @@
+---
+'@baseplate-dev/sync': patch
+---
+
+Add support for globs in onlyIfChanged command filter

.changeset/brave-parts-see.md

@@ -0,0 +1,5 @@
+---
+'@baseplate-dev/plugin-auth': patch
+---
+
+Support front and backend of new auth plugin

.changeset/easy-donuts-smoke.md

@@ -0,0 +1,5 @@
+---
+'@baseplate-dev/project-builder-web': patch
+---
+
+Fix bug in app creation that was re-using the same ID

.changeset/plenty-actors-help.md

@@ -0,0 +1,7 @@
+---
+'@baseplate-dev/project-builder-web': patch
+'@baseplate-dev/react-generators': patch
+'@baseplate-dev/ui-components': patch
+---
+
+Upgrade react-hook-form to 7.60.0

package.json

@@ -46,7 +46,7 @@
     "watch:tsc:root": "tsc -b tsconfig.build.json --preserveWatchOutput -w"
   },
   "lint-staged": {
-    "*.(js|ts|tsx|jsx|json|md|mdx|css|scss|yaml|yml|toml|html|svg|yml|yaml|json)": "prettier --write"
+    "*.(js|ts|tsx|jsx|json|md|mdx|css|scss|yaml|yml|toml|html|yml|yaml|json)": "prettier --write"
   },
   "dependencies": {
     "@changesets/cli": "2.28.1"

packages/fastify-generators/src/generators/auth/password-hasher-service/extractor.json

@@ -9,7 +9,6 @@
       "importMapProviders": {},
       "pathRootRelativePath": "{module-root}/services/password-hasher.service.ts",
       "projectExports": { "createPasswordHash": {}, "verifyPasswordHash": {} },
-      "template": "password-hasher.service.ts",
       "variables": {}
     }
   }

packages/fastify-generators/src/generators/auth/password-hasher-service/generated/index.ts

@@ -1,9 +1,11 @@
 import { AUTH_PASSWORD_HASHER_SERVICE_PATHS } from './template-paths.js';
+import { AUTH_PASSWORD_HASHER_SERVICE_RENDERERS } from './template-renderers.js';
 import { AUTH_PASSWORD_HASHER_SERVICE_IMPORTS } from './ts-import-providers.js';
 import { AUTH_PASSWORD_HASHER_SERVICE_TEMPLATES } from './typed-templates.js';
 
 export const AUTH_PASSWORD_HASHER_SERVICE_GENERATED = {
   imports: AUTH_PASSWORD_HASHER_SERVICE_IMPORTS,
   paths: AUTH_PASSWORD_HASHER_SERVICE_PATHS,
+  renderers: AUTH_PASSWORD_HASHER_SERVICE_RENDERERS,
   templates: AUTH_PASSWORD_HASHER_SERVICE_TEMPLATES,
 };

packages/fastify-generators/src/generators/auth/password-hasher-service/generated/template-renderers.ts

@@ -0,0 +1,59 @@
+import type { RenderTsTemplateFileActionInput } from '@baseplate-dev/core-generators';
+import type { BuilderAction } from '@baseplate-dev/sync';
+
+import { typescriptFileProvider } from '@baseplate-dev/core-generators';
+import { createGeneratorTask, createProviderType } from '@baseplate-dev/sync';
+
+import { AUTH_PASSWORD_HASHER_SERVICE_PATHS } from './template-paths.js';
+import { AUTH_PASSWORD_HASHER_SERVICE_TEMPLATES } from './typed-templates.js';
+
+export interface AuthPasswordHasherServiceRenderers {
+  passwordHasherService: {
+    render: (
+      options: Omit<
+        RenderTsTemplateFileActionInput<
+          typeof AUTH_PASSWORD_HASHER_SERVICE_TEMPLATES.passwordHasherService
+        >,
+        'destination' | 'importMapProviders' | 'template'
+      >,
+    ) => BuilderAction;
+  };
+}
+
+const authPasswordHasherServiceRenderers =
+  createProviderType<AuthPasswordHasherServiceRenderers>(
+    'auth-password-hasher-service-renderers',
+  );
+
+const authPasswordHasherServiceRenderersTask = createGeneratorTask({
+  dependencies: {
+    paths: AUTH_PASSWORD_HASHER_SERVICE_PATHS.provider,
+    typescriptFile: typescriptFileProvider,
+  },
+  exports: {
+    authPasswordHasherServiceRenderers:
+      authPasswordHasherServiceRenderers.export(),
+  },
+  run({ paths, typescriptFile }) {
+    return {
+      providers: {
+        authPasswordHasherServiceRenderers: {
+          passwordHasherService: {
+            render: (options) =>
+              typescriptFile.renderTemplateFile({
+                template:
+                  AUTH_PASSWORD_HASHER_SERVICE_TEMPLATES.passwordHasherService,
+                destination: paths.passwordHasherService,
+                ...options,
+              }),
+          },
+        },
+      },
+    };
+  },
+});
+
+export const AUTH_PASSWORD_HASHER_SERVICE_RENDERERS = {
+  provider: authPasswordHasherServiceRenderers,
+  task: authPasswordHasherServiceRenderersTask,
+};

packages/fastify-generators/src/generators/core/error-handler-service/templates/src/utils/zod.ts

@@ -20,8 +20,14 @@ import { BadRequestError } from './http-errors.js';
  */
 export const handleZodRequestValidationError = (error: unknown): never => {
   if (error instanceof ZodError) {
-    throw new BadRequestError('Validation failed', 'ZOD_VALIDATION_ERROR', {
-      errors: error.errors,
+    const formattedErrors = error.errors.map((err) => ({
+      path: err.path.join('.'),
+      message: err.message,
+      code: err.code,
+    }));
+
+    throw new BadRequestError('Validation failed', 'VALIDATION_ERROR', {
+      errors: formattedErrors,
     });
   }
 

packages/fastify-generators/src/generators/pothos/pothos-prisma-find-query/pothos-prisma-find-query.generator.ts

@@ -137,7 +137,7 @@ export const pothosPrismaFindQueryGenerator = createGenerator({
         );`,
               {
                 QUERY_EXPORT: `${lowerFirstModelName}Query`,
-                BUILDER: 'builder',
+                BUILDER: pothosTypesFile.getBuilderFragment(),
                 QUERY_NAME: quot(lowerFirstModelName),
                 OPTIONS: TsCodeUtils.mergeFragmentsAsObject(options, {
                   disableSort: true,

packages/project-builder-lib/package.json

@@ -58,7 +58,7 @@
     "immer": "10.1.1",
     "inflection": "3.0.0",
     "react": "catalog:",
-    "react-hook-form": "7.56.3",
+    "react-hook-form": "7.60.0",
     "zod": "catalog:",
     "zustand": "5.0.3"
   },

packages/project-builder-lib/src/definition/project-definition-container.ts

@@ -18,7 +18,7 @@ import {
 import {
   deserializeSchemaWithTransformedReferences,
   fixRefDeletions,
-  serializeSchemaFromRefPayload,
+  serializeSchema,
 } from '#src/references/index.js';
 import { createProjectDefinitionSchema } from '#src/schema/index.js';
 
@@ -100,9 +100,15 @@ export class ProjectDefinitionContainer {
    * @returns The serialized contents of the project definition
    */
   toSerializedContents(): string {
-    return stringifyPrettyStable(
-      serializeSchemaFromRefPayload(this.refPayload),
+    const serializedContents = serializeSchema(
+      createProjectDefinitionSchema,
+      this.definition,
+      {
+        defaultMode: 'strip',
+        plugins: this.pluginStore,
+      },
     );
+    return stringifyPrettyStable(serializedContents);
   }
 
   /**

packages/project-builder-lib/src/plugins/metadata/types.ts

@@ -63,6 +63,12 @@ export const pluginMetadataSchema = z.object({
       dependencies: z.array(pluginSpecDependencySchema).optional(),
     })
     .optional(),
+  /**
+   * Whether the plugin should be hidden in the project builder UI
+   *
+   * (It can be used once in the definition but cannot be added)
+   */
+  hidden: z.boolean().optional(),
 });
 
 export type PluginMetadata = z.infer<typeof pluginMetadataSchema>;

packages/project-builder-lib/src/references/extract-definition-refs.ts

@@ -124,6 +124,15 @@ export function extractDefinitionRefs<T>(value: T): ZodRefPayload<T> {
 
   const cleanData = extractDefinitionRefsRecursive(value, refContext, []);
 
+  // Simple sanity check to make sure we don't have duplicate IDs
+  const idSet = new Set<string>();
+  for (const entity of refContext.entitiesWithNameResolver) {
+    if (idSet.has(entity.id)) {
+      throw new Error(`Duplicate ID found: ${entity.id}`);
+    }
+    idSet.add(entity.id);
+  }
+
   return {
     data: cleanData as T,
     references: refContext.references,

packages/project-builder-lib/src/references/extract-definition-refs.unit.test.ts

@@ -8,7 +8,10 @@ import type { ZodRefContext } from './extract-definition-refs.js';
 
 import { createDefinitionEntityNameResolver } from './definition-ref-builder.js';
 import { deserializeSchemaWithTransformedReferences } from './deserialize-schema.js';
-import { extractDefinitionRefsRecursive } from './extract-definition-refs.js';
+import {
+  extractDefinitionRefs,
+  extractDefinitionRefsRecursive,
+} from './extract-definition-refs.js';
 import {
   DefinitionReferenceMarker,
   REF_ANNOTATIONS_MARKER_SYMBOL,
@@ -860,5 +863,125 @@ describe('extract-definition-refs', () => {
         });
       });
     });
+
+    describe('Duplicate ID Detection', () => {
+      it('should throw error when duplicate entity IDs are found', () => {
+        const testEntityType = new DefinitionEntityType('test', 'test');
+
+        const inputWithDuplicateIds = {
+          entity1: {
+            id: 'test:duplicate-id',
+            name: 'Entity One',
+            [REF_ANNOTATIONS_MARKER_SYMBOL]: {
+              entities: [
+                {
+                  type: testEntityType,
+                  getNameResolver: () => ({ resolveName: () => 'Entity One' }),
+                },
+              ],
+              references: [],
+              contextPaths: [],
+            },
+          },
+          entity2: {
+            id: 'test:duplicate-id', // Same ID as entity1
+            name: 'Entity Two',
+            [REF_ANNOTATIONS_MARKER_SYMBOL]: {
+              entities: [
+                {
+                  type: testEntityType,
+                  getNameResolver: () => ({ resolveName: () => 'Entity Two' }),
+                },
+              ],
+              references: [],
+              contextPaths: [],
+            },
+          },
+        };
+
+        expect(() => extractDefinitionRefs(inputWithDuplicateIds)).toThrow(
+          'Duplicate ID found: test:duplicate-id',
+        );
+      });
+    });
+  });
+
+  describe('Non-Recursive Function Tests (extractDefinitionRefs)', () => {
+    it('should process simple object with entity annotations', () => {
+      const testEntityType = new DefinitionEntityType('test', 'test');
+
+      const input = {
+        id: 'test:test-id',
+        name: 'Test Entity',
+        [REF_ANNOTATIONS_MARKER_SYMBOL]: {
+          entities: [
+            {
+              type: testEntityType,
+              getNameResolver: () => ({ resolveName: () => 'Test Entity' }),
+            },
+          ],
+          references: [],
+          contextPaths: [],
+        },
+      };
+
+      const result = extractDefinitionRefs(input);
+
+      expect(result.data).toEqual({
+        id: 'test:test-id',
+        name: 'Test Entity',
+      });
+      expect(result.entitiesWithNameResolver).toHaveLength(1);
+      expect(result.entitiesWithNameResolver[0]).toMatchObject({
+        id: 'test:test-id',
+        type: testEntityType,
+        path: [],
+        idPath: ['id'],
+      });
+      expect(result.references).toHaveLength(0);
+    });
+
+    it('should process object with both entities and references', () => {
+      const testEntityType = new DefinitionEntityType('test', 'test');
+      const refEntityType = new DefinitionEntityType('ref', 'ref');
+
+      const input = {
+        entity: {
+          id: 'test:entity-id',
+          name: 'Test Entity',
+          [REF_ANNOTATIONS_MARKER_SYMBOL]: {
+            entities: [
+              {
+                type: testEntityType,
+                getNameResolver: () => ({ resolveName: () => 'Test Entity' }),
+              },
+            ],
+            references: [],
+            contextPaths: [],
+          },
+        },
+        ref: new DefinitionReferenceMarker('ref:ref-id', {
+          type: refEntityType,
+          onDelete: 'RESTRICT',
+        }),
+      };
+
+      const result = extractDefinitionRefs(input);
+
+      expect(result.data).toEqual({
+        entity: {
+          id: 'test:entity-id',
+          name: 'Test Entity',
+        },
+        ref: 'ref:ref-id',
+      });
+      expect(result.entitiesWithNameResolver).toHaveLength(1);
+      expect(result.references).toHaveLength(1);
+      expect(result.references[0]).toMatchObject({
+        type: refEntityType,
+        path: ['ref'],
+        onDelete: 'RESTRICT',
+      });
+    });
   });
 });