@baseplate-dev/project-builder-lib 0.5.2 → 0.6.0

package/dist/schema/project-definition.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"project-definition.d.ts","sourceRoot":"","sources":["../../src/schema/project-definition.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,oBAAoB,CAAC;AAa9C,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAa3B,CAAC;AAEF,MAAM,MAAM,SAAS,GAAG,GAAG,CAAC,WAAW,CAAC,OAAO,eAAe,CAAC,CAAC;AAEhE,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAazC,CAAC;AAEF,MAAM,MAAM,sBAAsB,GAAG,GAAG,CAAC,UAAU,CACjD,OAAO,6BAA6B,CACrC,CAAC;AAEF,MAAM,MAAM,iBAAiB,GAAG,GAAG,CAAC,WAAW,CAC7C,OAAO,6BAA6B,CACrC,CAAC;AAEF,MAAM,MAAM,uBAAuB,GAAG,GAAG,CAAC,WAAW,CACnD,OAAO,6BAA6B,CACrC,CAAC"}
+{"version":3,"file":"project-definition.d.ts","sourceRoot":"","sources":["../../src/schema/project-definition.ts"],"names":[],"mappings":"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"}

package/dist/schema/project-definition.js

@@ -2,6 +2,8 @@ import { z } from 'zod';
 import { createBackendAppSchema } from './apps/backend/index.js';
 import { createWebAppSchema } from './apps/index.js';
 import { appEntityType } from './apps/types.js';
+import { checkUniqueField } from './creator/definition-issue-checkers.js';
+import { withIssueChecker } from './creator/definition-issue-registry.js';
 import { definitionSchema } from './creator/schema-creator.js';
 import { createFeaturesSchema } from './features/index.js';
 import { createLibrarySchema } from './libraries/library.js';
@@ -18,11 +20,21 @@ export const createAppSchema = definitionSchema((ctx) => ctx.refContext({ appSlo
 })));
 export const createProjectDefinitionSchema = definitionSchema((ctx) => z.object({
     cliVersion: z.string().nullish(),
-    apps: z.array(createAppSchema(ctx)).default([]),
+    apps: z
+        .array(createAppSchema(ctx))
+        .apply(withIssueChecker(checkUniqueField('name', { label: 'app name' })))
+        .apply(withIssueChecker(checkUniqueField('devPort', { label: 'dev port' })))
+        .default([]),
     libraries: z.array(createLibrarySchema(ctx)).default([]),
     features: createFeaturesSchema(ctx),
-    models: z.array(createModelSchema(ctx)).default([]),
-    enums: z.array(createEnumSchema(ctx)).optional(),
+    models: z
+        .array(createModelSchema(ctx))
+        .apply(withIssueChecker(checkUniqueField('name', { label: 'model name' })))
+        .default([]),
+    enums: z
+        .array(createEnumSchema(ctx))
+        .apply(withIssueChecker(checkUniqueField('name', { label: 'enum name' })))
+        .optional(),
     isInitialized: z.boolean().default(false),
     schemaVersion: z.number(),
     plugins: createPluginsSchema(ctx).optional(),

package/dist/schema/project-definition.js.map

@@ -1 +1 @@
-{"version":3,"file":"project-definition.js","sourceRoot":"","sources":["../../src/schema/project-definition.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,OAAO,EAAE,sBAAsB,EAAE,MAAM,yBAAyB,CAAC;AACjE,OAAO,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAC;AACrD,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAChD,OAAO,EAAE,gBAAgB,EAAE,MAAM,6BAA6B,CAAC;AAC/D,OAAO,EAAE,oBAAoB,EAAE,MAAM,qBAAqB,CAAC;AAC3D,OAAO,EAAE,mBAAmB,EAAE,MAAM,wBAAwB,CAAC;AAC7D,OAAO,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AACrD,OAAO,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAC;AACtD,OAAO,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAC;AACzD,OAAO,EAAE,oBAAoB,EAAE,MAAM,qBAAqB,CAAC;AAE3D,MAAM,CAAC,MAAM,eAAe,GAAG,gBAAgB,CAAC,CAAC,GAAG,EAAE,EAAE,CACtD,GAAG,CAAC,UAAU,CAAC,EAAE,OAAO,EAAE,aAAa,EAAE,EAAE,CAAC,EAAE,OAAO,EAAE,EAAE,EAAE,CACzD,GAAG,CAAC,OAAO,CACT,CAAC,CAAC,kBAAkB,CAAC,MAAM,EAAE;IAC3B,sBAAsB,CAAC,GAAG,EAAE,EAAE,OAAO,EAAE,CAAC;IACxC,kBAAkB,CAAC,GAAG,EAAE,EAAE,OAAO,EAAE,CAAC;CACrC,CAAC,EACF;IACE,IAAI,EAAE,aAAa;IACnB,QAAQ,EAAE,OAAO;CAClB,CACF,CACF,CACF,CAAC;AAIF,MAAM,CAAC,MAAM,6BAA6B,GAAG,gBAAgB,CAAC,CAAC,GAAG,EAAE,EAAE,CACpE,CAAC,CAAC,MAAM,CAAC;IACP,UAAU,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,OAAO,EAAE;IAChC,IAAI,EAAE,CAAC,CAAC,KAAK,CAAC,eAAe,CAAC,GAAG,CAAC,CAAC,CAAC,OAAO,CAAC,EAAE,CAAC;IAC/C,SAAS,EAAE,CAAC,CAAC,KAAK,CAAC,mBAAmB,CAAC,GAAG,CAAC,CAAC,CAAC,OAAO,CAAC,EAAE,CAAC;IACxD,QAAQ,EAAE,oBAAoB,CAAC,GAAG,CAAC;IACnC,MAAM,EAAE,CAAC,CAAC,KAAK,CAAC,iBAAiB,CAAC,GAAG,CAAC,CAAC,CAAC,OAAO,CAAC,EAAE,CAAC;IACnD,KAAK,EAAE,CAAC,CAAC,KAAK,CAAC,gBAAgB,CAAC,GAAG,CAAC,CAAC,CAAC,QAAQ,EAAE;IAChD,aAAa,EAAE,CAAC,CAAC,OAAO,EAAE,CAAC,OAAO,CAAC,KAAK,CAAC;IACzC,aAAa,EAAE,CAAC,CAAC,MAAM,EAAE;IACzB,OAAO,EAAE,mBAAmB,CAAC,GAAG,CAAC,CAAC,QAAQ,EAAE;IAC5C,QAAQ,EAAE,oBAAoB,CAAC,GAAG,CAAC;CACpC,CAAC,CACH,CAAC"}
+{"version":3,"file":"project-definition.js","sourceRoot":"","sources":["../../src/schema/project-definition.ts"],"names":[],"mappings":"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"}

package/dist/schema/settings/general.d.ts

@@ -6,7 +6,7 @@ import { z } from 'zod';
  */
 export declare const generalSettingsSchema: z.ZodObject<{
     name: z.ZodString;
-    packageScope: z.ZodDefault<z.ZodUnion<readonly [z.ZodLiteral<"">, z.ZodString]>>;
+    packageScope: z.ZodDefault<z.ZodString>;
     portOffset: z.ZodNumber;
 }, z.core.$strip>;
 /**

package/dist/schema/settings/general.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"general.d.ts","sourceRoot":"","sources":["../../../src/schema/settings/general.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB;;;;GAIG;AACH,eAAO,MAAM,qBAAqB;;;;iBAsChC,CAAC;AAEH;;GAEG;AACH,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AAEzE;;GAEG;AACH,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,qBAAqB,CAAC,CAAC"}
+{"version":3,"file":"general.d.ts","sourceRoot":"","sources":["../../../src/schema/settings/general.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB;;;;GAIG;AACH,eAAO,MAAM,qBAAqB;;;;iBAyChC,CAAC;AAEH;;GAEG;AACH,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AAEzE;;GAEG;AACH,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,qBAAqB,CAAC,CAAC"}

package/dist/schema/settings/general.js

@@ -21,7 +21,10 @@ export const generalSettingsSchema = z.object({
      * Example: "my-org" → "@my-org/backend", "@my-org/web"
      */
     packageScope: z
-        .union([z.literal(''), CASE_VALIDATORS.KEBAB_CASE])
+        .string()
+        .regex(/^([a-z0-9-]+)?$/, {
+        message: 'Must be kebab case (e.g. "my-org") or empty',
+    })
         .default(''),
     /**
      * The port offset to base the app ports on for development.

package/dist/schema/settings/general.js.map

@@ -1 +1 @@
-{"version":3,"file":"general.js","sourceRoot":"","sources":["../../../src/schema/settings/general.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AACvD,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB;;;;GAIG;AACH,MAAM,CAAC,MAAM,qBAAqB,GAAG,CAAC,CAAC,MAAM,CAAC;IAC5C;;;;;OAKG;IACH,IAAI,EAAE,eAAe,CAAC,UAAU;IAEhC;;;;;;OAMG;IACH,YAAY,EAAE,CAAC;SACZ,KAAK,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,EAAE,CAAC,EAAE,eAAe,CAAC,UAAU,CAAC,CAAC;SAClD,OAAO,CAAC,EAAE,CAAC;IAEd;;;;;;;;OAQG;IACH,UAAU,EAAE,CAAC;SACV,MAAM,EAAE;SACR,GAAG,CAAC,IAAI,CAAC;SACT,GAAG,CAAC,MAAM,CAAC;SACX,GAAG,EAAE;SACL,MAAM,CACL,CAAC,UAAU,EAAE,EAAE,CAAC,UAAU,GAAG,IAAI,KAAK,CAAC,EACvC,qEAAqE,CACtE;CACJ,CAAC,CAAC"}
+{"version":3,"file":"general.js","sourceRoot":"","sources":["../../../src/schema/settings/general.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AACvD,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB;;;;GAIG;AACH,MAAM,CAAC,MAAM,qBAAqB,GAAG,CAAC,CAAC,MAAM,CAAC;IAC5C;;;;;OAKG;IACH,IAAI,EAAE,eAAe,CAAC,UAAU;IAEhC;;;;;;OAMG;IACH,YAAY,EAAE,CAAC;SACZ,MAAM,EAAE;SACR,KAAK,CAAC,iBAAiB,EAAE;QACxB,OAAO,EAAE,6CAA6C;KACvD,CAAC;SACD,OAAO,CAAC,EAAE,CAAC;IAEd;;;;;;;;OAQG;IACH,UAAU,EAAE,CAAC;SACV,MAAM,EAAE;SACR,GAAG,CAAC,IAAI,CAAC;SACT,GAAG,CAAC,MAAM,CAAC;SACX,GAAG,EAAE;SACL,MAAM,CACL,CAAC,UAAU,EAAE,EAAE,CAAC,UAAU,GAAG,IAAI,KAAK,CAAC,EACvC,qEAAqE,CACtE;CACJ,CAAC,CAAC"}

package/dist/schema/settings/settings.d.ts

@@ -12,7 +12,7 @@ import { z } from 'zod';
 export declare const createSettingsSchema: (context: import("../index.js").DefinitionSchemaParserContext) => z.ZodObject<{
     general: z.ZodObject<{
         name: z.ZodString;
-        packageScope: z.ZodDefault<z.ZodUnion<readonly [z.ZodLiteral<"">, z.ZodString]>>;
+        packageScope: z.ZodDefault<z.ZodString>;
         portOffset: z.ZodNumber;
     }, z.core.$strip>;
     infrastructure: z.ZodOptional<z.ZodObject<{
@@ -70,6 +70,7 @@ export declare const createSettingsSchema: (context: import("../index.js").Defin
                 error: "error";
                 success: "success";
                 input: "input";
+                warning: "warning";
                 link: "link";
                 primary: "primary";
                 background: "background";
@@ -83,7 +84,6 @@ export declare const createSettingsSchema: (context: import("../index.js").Defin
                 accent: "accent";
                 accentForeground: "accentForeground";
                 successForeground: "successForeground";
-                warning: "warning";
                 warningForeground: "warningForeground";
                 errorForeground: "errorForeground";
                 primaryHover: "primaryHover";
@@ -102,6 +102,7 @@ export declare const createSettingsSchema: (context: import("../index.js").Defin
                 error: "error";
                 success: "success";
                 input: "input";
+                warning: "warning";
                 link: "link";
                 primary: "primary";
                 background: "background";
@@ -115,7 +116,6 @@ export declare const createSettingsSchema: (context: import("../index.js").Defin
                 accent: "accent";
                 accentForeground: "accentForeground";
                 successForeground: "successForeground";
-                warning: "warning";
                 warningForeground: "warningForeground";
                 errorForeground: "errorForeground";
                 primaryHover: "primaryHover";

package/dist/schema/settings/theme.d.ts

@@ -23,6 +23,7 @@ export declare const themeColorSchema: z.ZodRecord<z.ZodEnum<{
     error: "error";
     success: "success";
     input: "input";
+    warning: "warning";
     link: "link";
     primary: "primary";
     background: "background";
@@ -36,7 +37,6 @@ export declare const themeColorSchema: z.ZodRecord<z.ZodEnum<{
     accent: "accent";
     accentForeground: "accentForeground";
     successForeground: "successForeground";
-    warning: "warning";
     warningForeground: "warningForeground";
     errorForeground: "errorForeground";
     primaryHover: "primaryHover";
@@ -174,6 +174,7 @@ export declare const createThemeSchema: (context: import("#src/schema/creator/in
             error: "error";
             success: "success";
             input: "input";
+            warning: "warning";
             link: "link";
             primary: "primary";
             background: "background";
@@ -187,7 +188,6 @@ export declare const createThemeSchema: (context: import("#src/schema/creator/in
             accent: "accent";
             accentForeground: "accentForeground";
             successForeground: "successForeground";
-            warning: "warning";
             warningForeground: "warningForeground";
             errorForeground: "errorForeground";
             primaryHover: "primaryHover";
@@ -206,6 +206,7 @@ export declare const createThemeSchema: (context: import("#src/schema/creator/in
             error: "error";
             success: "success";
             input: "input";
+            warning: "warning";
             link: "link";
             primary: "primary";
             background: "background";
@@ -219,7 +220,6 @@ export declare const createThemeSchema: (context: import("#src/schema/creator/in
             accent: "accent";
             accentForeground: "accentForeground";
             successForeground: "successForeground";
-            warning: "warning";
             warningForeground: "warningForeground";
             errorForeground: "errorForeground";
             primaryHover: "primaryHover";

package/dist/testing/definition-helpers.test-helper.d.ts

@@ -0,0 +1,12 @@
+import type { FeatureConfig } from '#src/schema/features/feature.js';
+import type { ModelConfig, ModelConfigInput, ModelRelationFieldConfig, ModelScalarFieldConfig, ModelScalarFieldConfigInput, ModelUniqueConstraintConfig } from '#src/schema/models/index.js';
+export declare function createTestFeature(feature?: Partial<FeatureConfig>): FeatureConfig;
+export declare function createTestModel(model?: Partial<ModelConfigInput>): ModelConfig;
+export declare function createTestScalarField<TType extends ModelScalarFieldConfig['type'] = 'string'>(field?: Partial<ModelScalarFieldConfigInput & {
+    type: TType;
+}>): ModelScalarFieldConfig & {
+    type: TType;
+};
+export declare function createTestRelationField(relation?: Partial<ModelRelationFieldConfig>): ModelRelationFieldConfig;
+export declare function createTestUniqueConstraint(constraint?: Partial<ModelUniqueConstraintConfig>): ModelUniqueConstraintConfig;
+//# sourceMappingURL=definition-helpers.test-helper.d.ts.map

package/dist/testing/definition-helpers.test-helper.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"definition-helpers.test-helper.d.ts","sourceRoot":"","sources":["../../src/testing/definition-helpers.test-helper.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iCAAiC,CAAC;AACrE,OAAO,KAAK,EACV,WAAW,EACX,gBAAgB,EAChB,wBAAwB,EACxB,sBAAsB,EACtB,2BAA2B,EAC3B,2BAA2B,EAC5B,MAAM,6BAA6B,CAAC;AAgBrC,wBAAgB,iBAAiB,CAC/B,OAAO,GAAE,OAAO,CAAC,aAAa,CAAM,GACnC,aAAa,CAMf;AAED,wBAAgB,eAAe,CAC7B,KAAK,GAAE,OAAO,CAAC,gBAAgB,CAAM,GACpC,WAAW,CA4Bb;AAED,wBAAgB,qBAAqB,CACnC,KAAK,SAAS,sBAAsB,CAAC,MAAM,CAAC,GAAG,QAAQ,EAEvD,KAAK,GAAE,OAAO,CAAC,2BAA2B,GAAG;IAAE,IAAI,EAAE,KAAK,CAAA;CAAE,CAAM,GACjE,sBAAsB,GAAG;IAAE,IAAI,EAAE,KAAK,CAAA;CAAE,CAY1C;AAED,wBAAgB,uBAAuB,CACrC,QAAQ,CAAC,EAAE,OAAO,CAAC,wBAAwB,CAAC,GAC3C,wBAAwB,CAY1B;AAED,wBAAgB,0BAA0B,CACxC,UAAU,CAAC,EAAE,OAAO,CAAC,2BAA2B,CAAC,GAChD,2BAA2B,CAM7B"}

package/dist/testing/definition-helpers.test-helper.js

@@ -0,0 +1,77 @@
+import { faker } from '@faker-js/faker';
+import { capitalize } from 'es-toolkit';
+import { featureEntityType } from '#src/schema/features/feature.js';
+import { modelEntityType, modelForeignRelationEntityType, modelLocalRelationEntityType, modelScalarFieldEntityType, modelUniqueConstraintEntityType, } from '#src/schema/models/index.js';
+import { createModelSchema } from '#src/schema/models/models.js';
+import { createEmptyParserContext } from './parser-context.test-helper.js';
+const modelSchema = createModelSchema(createEmptyParserContext());
+export function createTestFeature(feature = {}) {
+    return {
+        id: featureEntityType.generateNewId(),
+        name: faker.word.noun(),
+        ...feature,
+    };
+}
+export function createTestModel(model = {}) {
+    const input = {
+        id: modelEntityType.generateNewId(),
+        name: capitalize(faker.word.noun()),
+        featureRef: 'mockFeature',
+        ...model,
+        model: {
+            fields: [
+                {
+                    id: modelScalarFieldEntityType.generateNewId(),
+                    name: 'id',
+                    type: 'uuid',
+                    options: { genUuid: true, default: '123' },
+                    isOptional: false,
+                },
+            ],
+            primaryKeyFieldRefs: ['id'],
+            ...model.model,
+        },
+        service: {
+            create: { enabled: false },
+            update: { enabled: false },
+            delete: { enabled: false },
+            transformers: [],
+            ...model.service,
+        },
+    };
+    return modelSchema.parse(input);
+}
+export function createTestScalarField(field = {}) {
+    return {
+        id: modelScalarFieldEntityType.generateNewId(),
+        name: faker.word.noun(),
+        type: 'string',
+        isOptional: false,
+        ...field,
+        options: {
+            default: '123',
+            ...field.options,
+        },
+    };
+}
+export function createTestRelationField(relation) {
+    return {
+        id: modelLocalRelationEntityType.generateNewId(),
+        foreignId: modelForeignRelationEntityType.generateNewId(),
+        name: 'mockRelation',
+        modelRef: 'mockModel',
+        foreignRelationName: 'mockForeignRelation',
+        references: [],
+        onDelete: 'Cascade',
+        onUpdate: 'Restrict',
+        ...relation,
+    };
+}
+export function createTestUniqueConstraint(constraint) {
+    return {
+        id: modelUniqueConstraintEntityType.generateNewId(),
+        fields: [],
+        ...constraint,
+    };
+}
+//# sourceMappingURL=definition-helpers.test-helper.js.map

package/dist/testing/definition-helpers.test-helper.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"definition-helpers.test-helper.js","sourceRoot":"","sources":["../../src/testing/definition-helpers.test-helper.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,iBAAiB,CAAC;AACxC,OAAO,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAYxC,OAAO,EAAE,iBAAiB,EAAE,MAAM,iCAAiC,CAAC;AACpE,OAAO,EACL,eAAe,EACf,8BAA8B,EAC9B,4BAA4B,EAC5B,0BAA0B,EAC1B,+BAA+B,GAChC,MAAM,6BAA6B,CAAC;AACrC,OAAO,EAAE,iBAAiB,EAAE,MAAM,8BAA8B,CAAC;AAEjE,OAAO,EAAE,wBAAwB,EAAE,MAAM,iCAAiC,CAAC;AAE3E,MAAM,WAAW,GAAG,iBAAiB,CAAC,wBAAwB,EAAE,CAAC,CAAC;AAElE,MAAM,UAAU,iBAAiB,CAC/B,UAAkC,EAAE;IAEpC,OAAO;QACL,EAAE,EAAE,iBAAiB,CAAC,aAAa,EAAE;QACrC,IAAI,EAAE,KAAK,CAAC,IAAI,CAAC,IAAI,EAAE;QACvB,GAAG,OAAO;KACX,CAAC;AACJ,CAAC;AAED,MAAM,UAAU,eAAe,CAC7B,QAAmC,EAAE;IAErC,MAAM,KAAK,GAAqB;QAC9B,EAAE,EAAE,eAAe,CAAC,aAAa,EAAE;QACnC,IAAI,EAAE,UAAU,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,EAAE,CAAC;QACnC,UAAU,EAAE,aAAa;QACzB,GAAG,KAAK;QACR,KAAK,EAAE;YACL,MAAM,EAAE;gBACN;oBACE,EAAE,EAAE,0BAA0B,CAAC,aAAa,EAAE;oBAC9C,IAAI,EAAE,IAAI;oBACV,IAAI,EAAE,MAAM;oBACZ,OAAO,EAAE,EAAE,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,KAAK,EAAE;oBAC1C,UAAU,EAAE,KAAK;iBAClB;aACF;YACD,mBAAmB,EAAE,CAAC,IAAI,CAAC;YAC3B,GAAG,KAAK,CAAC,KAAK;SACf;QACD,OAAO,EAAE;YACP,MAAM,EAAE,EAAE,OAAO,EAAE,KAAK,EAAE;YAC1B,MAAM,EAAE,EAAE,OAAO,EAAE,KAAK,EAAE;YAC1B,MAAM,EAAE,EAAE,OAAO,EAAE,KAAK,EAAE;YAC1B,YAAY,EAAE,EAAE;YAChB,GAAG,KAAK,CAAC,OAAO;SACjB;KACF,CAAC;IACF,OAAO,WAAW,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;AAClC,CAAC;AAED,MAAM,UAAU,qBAAqB,CAGnC,QAAgE,EAAE;IAElE,OAAO;QACL,EAAE,EAAE,0BAA0B,CAAC,aAAa,EAAE;QAC9C,IAAI,EAAE,KAAK,CAAC,IAAI,CAAC,IAAI,EAAE;QACvB,IAAI,EAAE,QAAQ;QACd,UAAU,EAAE,KAAK;QACjB,GAAG,KAAK;QACR,OAAO,EAAE;YACP,OAAO,EAAE,KAAK;YACd,GAAG,KAAK,CAAC,OAAO;SACjB;KAC0C,CAAC;AAChD,CAAC;AAED,MAAM,UAAU,uBAAuB,CACrC,QAA4C;IAE5C,OAAO;QACL,EAAE,EAAE,4BAA4B,CAAC,aAAa,EAAE;QAChD,SAAS,EAAE,8BAA8B,CAAC,aAAa,EAAE;QACzD,IAAI,EAAE,cAAc;QACpB,QAAQ,EAAE,WAAW;QACrB,mBAAmB,EAAE,qBAAqB;QAC1C,UAAU,EAAE,EAAE;QACd,QAAQ,EAAE,SAAS;QACnB,QAAQ,EAAE,UAAU;QACpB,GAAG,QAAQ;KACZ,CAAC;AACJ,CAAC;AAED,MAAM,UAAU,0BAA0B,CACxC,UAAiD;IAEjD,OAAO;QACL,EAAE,EAAE,+BAA+B,CAAC,aAAa,EAAE;QACnD,MAAM,EAAE,EAAE;QACV,GAAG,UAAU;KACd,CAAC;AACJ,CAAC"}

package/dist/testing/expression-stub-parser.test-helper.d.ts

@@ -0,0 +1,59 @@
+import { z } from 'zod';
+import type { RefExpressionParseResult } from '#src/references/expression-types.js';
+import type { DefinitionEntityType } from '#src/references/types.js';
+import { RefExpressionParser } from '#src/references/expression-types.js';
+/**
+ * A no-op stub parser for testing the expression infrastructure.
+ *
+ * This parser doesn't actually parse anything - it's used to verify
+ * that the marker creation, collection, and flow work correctly
+ * before implementing real parsers.
+ *
+ * @example
+ * ```typescript
+ * // Use in schema definition for testing
+ * const schema = z.object({
+ *   expression: ctx.withExpression(stubParser),
+ * });
+ * ```
+ */
+declare class StubParser extends RefExpressionParser<string, undefined> {
+    readonly name = "stub";
+    createSchema(): z.ZodType<string>;
+    parse(): RefExpressionParseResult<undefined>;
+    getWarnings(): [];
+    getDependencies(): [];
+    updateForRename(value: string): string;
+}
+/**
+ * Singleton instance of StubParser for convenience.
+ */
+export declare const stubParser: StubParser;
+/**
+ * A stub parser that requires slots for testing slot resolution.
+ *
+ * This parser accepts a generic slots parameter to test that expression
+ * slots are correctly resolved to their ancestor paths.
+ *
+ * @example
+ * ```typescript
+ * const modelType = createEntityType('model');
+ * const parserWithSlots = new StubParserWithSlots<{ model: typeof modelType }>();
+ *
+ * ctx.refContext({ modelSlot: modelType }, ({ modelSlot }) =>
+ *   z.object({
+ *     condition: ctx.withExpression(parserWithSlots, { model: modelSlot }),
+ *   })
+ * );
+ * ```
+ */
+export declare class StubParserWithSlots<TSlots extends Record<string, DefinitionEntityType>> extends RefExpressionParser<string, undefined, TSlots> {
+    readonly name = "stub-with-slots";
+    createSchema(): z.ZodType<string>;
+    parse(): RefExpressionParseResult<undefined>;
+    getWarnings(): [];
+    getDependencies(): [];
+    updateForRename(value: string): string;
+}
+export {};
+//# sourceMappingURL=expression-stub-parser.test-helper.d.ts.map

package/dist/testing/expression-stub-parser.test-helper.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"expression-stub-parser.test-helper.d.ts","sourceRoot":"","sources":["../../src/testing/expression-stub-parser.test-helper.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,qCAAqC,CAAC;AACpF,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,0BAA0B,CAAC;AAErE,OAAO,EAAE,mBAAmB,EAAE,MAAM,qCAAqC,CAAC;AAE1E;;;;;;;;;;;;;;GAcG;AACH,cAAM,UAAW,SAAQ,mBAAmB,CAAC,MAAM,EAAE,SAAS,CAAC;IAC7D,QAAQ,CAAC,IAAI,UAAU;IAEvB,YAAY,IAAI,CAAC,CAAC,OAAO,CAAC,MAAM,CAAC;IAIjC,KAAK,IAAI,wBAAwB,CAAC,SAAS,CAAC;IAI5C,WAAW,IAAI,EAAE;IAKjB,eAAe,IAAI,EAAE;IAKrB,eAAe,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM;CAIvC;AAED;;GAEG;AACH,eAAO,MAAM,UAAU,YAAmB,CAAC;AAE3C;;;;;;;;;;;;;;;;;GAiBG;AACH,qBAAa,mBAAmB,CAC9B,MAAM,SAAS,MAAM,CAAC,MAAM,EAAE,oBAAoB,CAAC,CACnD,SAAQ,mBAAmB,CAAC,MAAM,EAAE,SAAS,EAAE,MAAM,CAAC;IACtD,QAAQ,CAAC,IAAI,qBAAqB;IAClC,YAAY,IAAI,CAAC,CAAC,OAAO,CAAC,MAAM,CAAC;IAIjC,KAAK,IAAI,wBAAwB,CAAC,SAAS,CAAC;IAI5C,WAAW,IAAI,EAAE;IAIjB,eAAe,IAAI,EAAE;IAIrB,eAAe,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM;CAGvC"}

package/dist/testing/expression-stub-parser.test-helper.js

@@ -0,0 +1,79 @@
+import { z } from 'zod';
+import { RefExpressionParser } from '#src/references/expression-types.js';
+/**
+ * A no-op stub parser for testing the expression infrastructure.
+ *
+ * This parser doesn't actually parse anything - it's used to verify
+ * that the marker creation, collection, and flow work correctly
+ * before implementing real parsers.
+ *
+ * @example
+ * ```typescript
+ * // Use in schema definition for testing
+ * const schema = z.object({
+ *   expression: ctx.withExpression(stubParser),
+ * });
+ * ```
+ */
+class StubParser extends RefExpressionParser {
+    name = 'stub';
+    createSchema() {
+        return z.string();
+    }
+    parse() {
+        return { success: true, value: undefined };
+    }
+    getWarnings() {
+        // No warnings from stub parser
+        return [];
+    }
+    getDependencies() {
+        // No dependencies tracked by stub parser
+        return [];
+    }
+    updateForRename(value) {
+        // No rename handling - return value unchanged
+        return value;
+    }
+}
+/**
+ * Singleton instance of StubParser for convenience.
+ */
+export const stubParser = new StubParser();
+/**
+ * A stub parser that requires slots for testing slot resolution.
+ *
+ * This parser accepts a generic slots parameter to test that expression
+ * slots are correctly resolved to their ancestor paths.
+ *
+ * @example
+ * ```typescript
+ * const modelType = createEntityType('model');
+ * const parserWithSlots = new StubParserWithSlots<{ model: typeof modelType }>();
+ *
+ * ctx.refContext({ modelSlot: modelType }, ({ modelSlot }) =>
+ *   z.object({
+ *     condition: ctx.withExpression(parserWithSlots, { model: modelSlot }),
+ *   })
+ * );
+ * ```
+ */
+export class StubParserWithSlots extends RefExpressionParser {
+    name = 'stub-with-slots';
+    createSchema() {
+        return z.string();
+    }
+    parse() {
+        return { success: true, value: undefined };
+    }
+    getWarnings() {
+        return [];
+    }
+    getDependencies() {
+        return [];
+    }
+    updateForRename(value) {
+        return value;
+    }
+}
+//# sourceMappingURL=expression-stub-parser.test-helper.js.map

package/dist/testing/expression-stub-parser.test-helper.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"expression-stub-parser.test-helper.js","sourceRoot":"","sources":["../../src/testing/expression-stub-parser.test-helper.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAKxB,OAAO,EAAE,mBAAmB,EAAE,MAAM,qCAAqC,CAAC;AAE1E;;;;;;;;;;;;;;GAcG;AACH,MAAM,UAAW,SAAQ,mBAAsC;IACpD,IAAI,GAAG,MAAM,CAAC;IAEvB,YAAY;QACV,OAAO,CAAC,CAAC,MAAM,EAAE,CAAC;IACpB,CAAC;IAED,KAAK;QACH,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,KAAK,EAAE,SAAS,EAAE,CAAC;IAC7C,CAAC;IAED,WAAW;QACT,+BAA+B;QAC/B,OAAO,EAAE,CAAC;IACZ,CAAC;IAED,eAAe;QACb,yCAAyC;QACzC,OAAO,EAAE,CAAC;IACZ,CAAC;IAED,eAAe,CAAC,KAAa;QAC3B,8CAA8C;QAC9C,OAAO,KAAK,CAAC;IACf,CAAC;CACF;AAED;;GAEG;AACH,MAAM,CAAC,MAAM,UAAU,GAAG,IAAI,UAAU,EAAE,CAAC;AAE3C;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,OAAO,mBAEX,SAAQ,mBAA8C;IAC7C,IAAI,GAAG,iBAAiB,CAAC;IAClC,YAAY;QACV,OAAO,CAAC,CAAC,MAAM,EAAE,CAAC;IACpB,CAAC;IAED,KAAK;QACH,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,KAAK,EAAE,SAAS,EAAE,CAAC;IAC7C,CAAC;IAED,WAAW;QACT,OAAO,EAAE,CAAC;IACZ,CAAC;IAED,eAAe;QACb,OAAO,EAAE,CAAC;IACZ,CAAC;IAED,eAAe,CAAC,KAAa;QAC3B,OAAO,KAAK,CAAC;IACf,CAAC;CACF"}

package/dist/testing/expression-warning-parser.test-helper.d.ts

@@ -0,0 +1,39 @@
+import { z } from 'zod';
+import type { ExpressionValidationContext, RefExpressionParseResult, RefExpressionWarning } from '#src/references/expression-types.js';
+import { RefExpressionParser } from '#src/references/expression-types.js';
+/**
+ * A test parser that always returns a configurable set of warnings.
+ *
+ * Used to test expression validation infrastructure without needing
+ * real expression parsing logic.
+ *
+ * @example
+ * ```typescript
+ * const parser = new WarningParser([{ message: 'Field not found' }]);
+ * const schema = ctx.withExpression(parser);
+ * ```
+ */
+export declare class WarningParser extends RefExpressionParser<string, string> {
+    readonly name = "warning-parser";
+    private readonly warningsToReturn;
+    constructor(warnings: RefExpressionWarning[]);
+    createSchema(): z.ZodType<string>;
+    parse(value: string): RefExpressionParseResult<string>;
+    getWarnings(_parseResult: string, _context: ExpressionValidationContext): RefExpressionWarning[];
+    getDependencies(): [];
+    updateForRename(value: string): string;
+}
+/**
+ * A test parser whose parse() returns a failure result.
+ *
+ * Used to test that expression validation gracefully handles parse failures.
+ */
+export declare class FailingParser extends RefExpressionParser<string, never> {
+    readonly name = "failing-parser";
+    createSchema(): z.ZodType<string>;
+    parse(): RefExpressionParseResult<never>;
+    getWarnings(): RefExpressionWarning[];
+    getDependencies(): [];
+    updateForRename(value: string): string;
+}
+//# sourceMappingURL=expression-warning-parser.test-helper.d.ts.map

package/dist/testing/expression-warning-parser.test-helper.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"expression-warning-parser.test-helper.d.ts","sourceRoot":"","sources":["../../src/testing/expression-warning-parser.test-helper.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EACV,2BAA2B,EAC3B,wBAAwB,EACxB,oBAAoB,EACrB,MAAM,qCAAqC,CAAC;AAE7C,OAAO,EAAE,mBAAmB,EAAE,MAAM,qCAAqC,CAAC;AAE1E;;;;;;;;;;;GAWG;AACH,qBAAa,aAAc,SAAQ,mBAAmB,CAAC,MAAM,EAAE,MAAM,CAAC;IACpE,QAAQ,CAAC,IAAI,oBAAoB;IACjC,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAAyB;gBAE9C,QAAQ,EAAE,oBAAoB,EAAE;IAK5C,YAAY,IAAI,CAAC,CAAC,OAAO,CAAC,MAAM,CAAC;IAIjC,KAAK,CAAC,KAAK,EAAE,MAAM,GAAG,wBAAwB,CAAC,MAAM,CAAC;IAItD,WAAW,CACT,YAAY,EAAE,MAAM,EACpB,QAAQ,EAAE,2BAA2B,GACpC,oBAAoB,EAAE;IAIzB,eAAe,IAAI,EAAE;IAIrB,eAAe,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM;CAGvC;AAED;;;;GAIG;AACH,qBAAa,aAAc,SAAQ,mBAAmB,CAAC,MAAM,EAAE,KAAK,CAAC;IACnE,QAAQ,CAAC,IAAI,oBAAoB;IAEjC,YAAY,IAAI,CAAC,CAAC,OAAO,CAAC,MAAM,CAAC;IAIjC,KAAK,IAAI,wBAAwB,CAAC,KAAK,CAAC;IAIxC,WAAW,IAAI,oBAAoB,EAAE;IAKrC,eAAe,IAAI,EAAE;IAIrB,eAAe,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM;CAGvC"}

package/dist/testing/expression-warning-parser.test-helper.js

@@ -0,0 +1,62 @@
+import { z } from 'zod';
+import { RefExpressionParser } from '#src/references/expression-types.js';
+/**
+ * A test parser that always returns a configurable set of warnings.
+ *
+ * Used to test expression validation infrastructure without needing
+ * real expression parsing logic.
+ *
+ * @example
+ * ```typescript
+ * const parser = new WarningParser([{ message: 'Field not found' }]);
+ * const schema = ctx.withExpression(parser);
+ * ```
+ */
+export class WarningParser extends RefExpressionParser {
+    name = 'warning-parser';
+    warningsToReturn;
+    constructor(warnings) {
+        super();
+        this.warningsToReturn = warnings;
+    }
+    createSchema() {
+        return z.string();
+    }
+    parse(value) {
+        return { success: true, value };
+    }
+    getWarnings(_parseResult, _context) {
+        return this.warningsToReturn;
+    }
+    getDependencies() {
+        return [];
+    }
+    updateForRename(value) {
+        return value;
+    }
+}
+/**
+ * A test parser whose parse() returns a failure result.
+ *
+ * Used to test that expression validation gracefully handles parse failures.
+ */
+export class FailingParser extends RefExpressionParser {
+    name = 'failing-parser';
+    createSchema() {
+        return z.string();
+    }
+    parse() {
+        return { success: false, error: 'Parse failed' };
+    }
+    getWarnings() {
+        // Never called — parse() always returns failure, handled by validate()
+        return [];
+    }
+    getDependencies() {
+        return [];
+    }
+    updateForRename(value) {
+        return value;
+    }
+}
+//# sourceMappingURL=expression-warning-parser.test-helper.js.map

package/dist/testing/expression-warning-parser.test-helper.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"expression-warning-parser.test-helper.js","sourceRoot":"","sources":["../../src/testing/expression-warning-parser.test-helper.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAQxB,OAAO,EAAE,mBAAmB,EAAE,MAAM,qCAAqC,CAAC;AAE1E;;;;;;;;;;;GAWG;AACH,MAAM,OAAO,aAAc,SAAQ,mBAAmC;IAC3D,IAAI,GAAG,gBAAgB,CAAC;IAChB,gBAAgB,CAAyB;IAE1D,YAAY,QAAgC;QAC1C,KAAK,EAAE,CAAC;QACR,IAAI,CAAC,gBAAgB,GAAG,QAAQ,CAAC;IACnC,CAAC;IAED,YAAY;QACV,OAAO,CAAC,CAAC,MAAM,EAAE,CAAC;IACpB,CAAC;IAED,KAAK,CAAC,KAAa;QACjB,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,KAAK,EAAE,CAAC;IAClC,CAAC;IAED,WAAW,CACT,YAAoB,EACpB,QAAqC;QAErC,OAAO,IAAI,CAAC,gBAAgB,CAAC;IAC/B,CAAC;IAED,eAAe;QACb,OAAO,EAAE,CAAC;IACZ,CAAC;IAED,eAAe,CAAC,KAAa;QAC3B,OAAO,KAAK,CAAC;IACf,CAAC;CACF;AAED;;;;GAIG;AACH,MAAM,OAAO,aAAc,SAAQ,mBAAkC;IAC1D,IAAI,GAAG,gBAAgB,CAAC;IAEjC,YAAY;QACV,OAAO,CAAC,CAAC,MAAM,EAAE,CAAC;IACpB,CAAC;IAED,KAAK;QACH,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,cAAc,EAAE,CAAC;IACnD,CAAC;IAED,WAAW;QACT,uEAAuE;QACvE,OAAO,EAAE,CAAC;IACZ,CAAC;IAED,eAAe;QACb,OAAO,EAAE,CAAC;IACZ,CAAC;IAED,eAAe,CAAC,KAAa;QAC3B,OAAO,KAAK,CAAC;IACf,CAAC;CACF"}

package/dist/testing/index.d.ts

@@ -0,0 +1,5 @@
+export * from './definition-helpers.test-helper.js';
+export * from './expression-stub-parser.test-helper.js';
+export * from './parser-context.test-helper.js';
+export * from './project-definition-container.test-helper.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/testing/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/testing/index.ts"],"names":[],"mappings":"AAAA,cAAc,qCAAqC,CAAC;AACpD,cAAc,yCAAyC,CAAC;AACxD,cAAc,iCAAiC,CAAC;AAChD,cAAc,+CAA+C,CAAC"}

package/dist/testing/index.js

@@ -0,0 +1,5 @@
+export * from './definition-helpers.test-helper.js';
+export * from './expression-stub-parser.test-helper.js';
+export * from './parser-context.test-helper.js';
+export * from './project-definition-container.test-helper.js';
+//# sourceMappingURL=index.js.map

package/dist/testing/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/testing/index.ts"],"names":[],"mappings":"AAAA,cAAc,qCAAqC,CAAC;AACpD,cAAc,yCAAyC,CAAC;AACxD,cAAc,iCAAiC,CAAC;AAChD,cAAc,+CAA+C,CAAC"}

package/dist/testing/parser-context.test-helper.d.ts

@@ -0,0 +1,8 @@
+import type { DefinitionSchemaParserContext } from '../schema/creator/types.js';
+/**
+ * Creates a definition schema parser context with no plugins.
+ * Useful for unit tests that need to build or parse definition schemas
+ * without a full project context.
+ */
+export declare function createEmptyParserContext(): DefinitionSchemaParserContext;
+//# sourceMappingURL=parser-context.test-helper.d.ts.map

package/dist/testing/parser-context.test-helper.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parser-context.test-helper.d.ts","sourceRoot":"","sources":["../../src/testing/parser-context.test-helper.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,6BAA6B,EAAE,MAAM,4BAA4B,CAAC;AAUhF;;;;GAIG;AACH,wBAAgB,wBAAwB,IAAI,6BAA6B,CAGxE"}

package/dist/testing/parser-context.test-helper.js

@@ -0,0 +1,16 @@
+import { createPluginSpecStore } from '../parser/parser.js';
+import { createDefinitionSchemaParserContext } from '../schema/creator/schema-creator.js';
+const emptyPluginStore = {
+    availablePlugins: [],
+    coreModules: [],
+};
+/**
+ * Creates a definition schema parser context with no plugins.
+ * Useful for unit tests that need to build or parse definition schemas
+ * without a full project context.
+ */
+export function createEmptyParserContext() {
+    const pluginSpecStore = createPluginSpecStore(emptyPluginStore, {});
+    return createDefinitionSchemaParserContext({ plugins: pluginSpecStore });
+}
+//# sourceMappingURL=parser-context.test-helper.js.map

package/dist/testing/parser-context.test-helper.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"parser-context.test-helper.js","sourceRoot":"","sources":["../../src/testing/parser-context.test-helper.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,qBAAqB,EAAE,MAAM,qBAAqB,CAAC;AAC5D,OAAO,EAAE,mCAAmC,EAAE,MAAM,qCAAqC,CAAC;AAE1F,MAAM,gBAAgB,GAAG;IACvB,gBAAgB,EAAE,EAAE;IACpB,WAAW,EAAE,EAAE;CAChB,CAAC;AAEF;;;;GAIG;AACH,MAAM,UAAU,wBAAwB;IACtC,MAAM,eAAe,GAAG,qBAAqB,CAAC,gBAAgB,EAAE,EAAE,CAAC,CAAC;IACpE,OAAO,mCAAmC,CAAC,EAAE,OAAO,EAAE,eAAe,EAAE,CAAC,CAAC;AAC3E,CAAC"}

package/dist/{definition/project-definition-container.test-utils.d.ts → testing/project-definition-container.test-helper.d.ts}

@@ -1,6 +1,8 @@
 import type { ProjectDefinition, ProjectDefinitionInput } from '#src/schema/project-definition.js';
-import { ProjectDefinitionContainer } from './project-definition-container.js';
+import type { EntityServiceContext } from '#src/tools/entity-service/types.js';
+import { ProjectDefinitionContainer } from '#src/definition/project-definition-container.js';
 export declare function createTestProjectDefinition(input?: Partial<ProjectDefinition>): ProjectDefinition;
 export declare function createTestProjectDefinitionInput(input?: Partial<ProjectDefinitionInput>): ProjectDefinitionInput;
 export declare function createTestProjectDefinitionContainer(input?: Partial<ProjectDefinitionInput>): ProjectDefinitionContainer;
-//# sourceMappingURL=project-definition-container.test-utils.d.ts.map
+export declare function createTestEntityServiceContext(input?: Partial<ProjectDefinitionInput>): EntityServiceContext;
+//# sourceMappingURL=project-definition-container.test-helper.d.ts.map

package/dist/testing/project-definition-container.test-helper.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"project-definition-container.test-helper.d.ts","sourceRoot":"","sources":["../../src/testing/project-definition-container.test-helper.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,iBAAiB,EACjB,sBAAsB,EACvB,MAAM,mCAAmC,CAAC;AAC3C,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,oCAAoC,CAAC;AAE/E,OAAO,EAAE,0BAA0B,EAAE,MAAM,iDAAiD,CAAC;AAO7F,wBAAgB,2BAA2B,CACzC,KAAK,GAAE,OAAO,CAAC,iBAAiB,CAAM,GACrC,iBAAiB,CAkBnB;AAED,wBAAgB,gCAAgC,CAC9C,KAAK,GAAE,OAAO,CAAC,sBAAsB,CAAM,GAC1C,sBAAsB,CAKxB;AAED,wBAAgB,oCAAoC,CAClD,KAAK,GAAE,OAAO,CAAC,sBAAsB,CAAM,GAC1C,0BAA0B,CA+B5B;AAED,wBAAgB,8BAA8B,CAC5C,KAAK,GAAE,OAAO,CAAC,sBAAsB,CAAM,GAC1C,oBAAoB,CAEtB"}