@builder-builder/builder 0.0.13 → 0.0.15

package/dist/validate/result.js

@@ -1,4 +1 @@
-import { builderError } from '../exception.js';
-export function builderErrorInvalidInput(target, location = []) {
-    return { ...builderError('invalid-input', location), target };
-}
+export {};

package/dist/validate/ui.d.ts

@@ -1,8 +1,8 @@
 import type { BuilderModelSerialised, BuilderRefEntities, BuilderUISerialised, BuilderUIValidated } from '../entities/index';
-import type { BuilderErrorLocation, BuilderErrors } from '../exception';
 import type { BuilderResolve } from './resolve';
 import type { ValidationResult } from './result';
+import { BuilderValidateErrors } from './errors.js';
 export type BuilderUIValidationResult = ValidationResult<BuilderUIValidated>;
-export declare function validateUI(input: unknown, references?: BuilderRefEntities): BuilderUIValidationResult;
-export declare function validateUIStructure(ui: BuilderUISerialised, resolve: BuilderResolve, location: BuilderErrorLocation): readonly [BuilderUIValidated, BuilderErrors];
-export declare function checkUIExpectations(mergedModel: BuilderModelSerialised, ui: BuilderUIValidated, location: BuilderErrorLocation): BuilderErrors;
+export declare function validateUI(input: unknown, references?: BuilderRefEntities, errors?: BuilderValidateErrors): BuilderUIValidationResult;
+export declare function validateUIStructure(ui: BuilderUISerialised, resolve: BuilderResolve, errors: BuilderValidateErrors): BuilderUIValidated;
+export declare function checkUIExpectations(mergedModel: BuilderModelSerialised, ui: BuilderUIValidated, errors: BuilderValidateErrors): void;

package/dist/validate/ui.js

@@ -1,77 +1,95 @@
 import { check } from '../check.js';
-import { BuilderUISerialisedSchema, serialise, uis } from '../entities/index.js';
+import { BuilderUIInputMetadataSchema, BuilderUISerialisedSchema, serialise, uis } from '../entities/index.js';
 import { validate } from './brand.js';
+import { BuilderValidateErrors } from './errors.js';
 import { checkExpectations } from './expectations.js';
 import { resolver } from './resolve.js';
-import { builderErrorInvalidInput } from './result.js';
-export function validateUI(input, references = []) {
+export function validateUI(input, references = [], errors = new BuilderValidateErrors()) {
     if (!check.is(BuilderUISerialisedSchema, input)) {
-        const errors = [builderErrorInvalidInput('ui')];
-        return [validate(serialise.ui(uis())), errors];
+        errors.invalidInput('ui');
+        return [validate(serialise.ui(uis())), errors.errors];
     }
-    const resolve = resolver(references);
-    const [structure, errors] = validateUIStructure(input, resolve, []);
-    return [validate(structure), errors];
+    const resolve = resolver(errors, references);
+    const structure = validateUIStructure(input, resolve, errors);
+    return [validate(structure), errors.errors];
 }
-export function validateUIStructure(ui, resolve, location) {
-    const errors = [];
-    const childUIs = ui.uis.flatMap((part, partIndex) => {
-        const partLocation = [...location, 'uis', partIndex];
-        const [resolved, partErrors] = resolve(part, partLocation);
-        errors.push(...partErrors);
-        if (resolved == null || !check.is(BuilderUISerialisedSchema, resolved)) {
-            return [];
-        }
-        const [child, childErrors] = validateUIStructure(resolved, resolve, partLocation);
-        errors.push(...childErrors);
-        return [child];
-    });
-    const [items, itemErrors] = walkItems(ui.items, resolve, [...location, 'items']);
-    errors.push(...itemErrors);
+export function validateUIStructure(ui, resolve, errors) {
+    const childUIs = walkChildUIs();
+    const items = errors.scope('items', () => walkItems(ui.items));
     const data = {
         ...ui,
         uis: childUIs,
         items
     };
-    return [data, errors];
-}
-export function checkUIExpectations(mergedModel, ui, location) {
-    return [
-        ...checkExpectations(mergedModel, ui.expectations, [...location, 'expectations']),
-        ...ui.uis.flatMap((nested, nestedIndex) => checkUIExpectations(mergedModel, nested, [
-            ...location,
-            'uis',
-            nestedIndex
-        ]))
-    ];
+    return data;
+    function walkChildUIs() {
+        return errors.scope('uis', () => ui.uis.flatMap((part, partIndex) => errors.scope(partIndex, () => {
+            const resolved = resolve(part);
+            if (resolved == null || !check.is(BuilderUISerialisedSchema, resolved)) {
+                return [];
+            }
+            return [validateUIStructure(resolved, resolve, errors)];
+        })));
+    }
+    function walkItems(parts) {
+        return parts.map((item, itemIndex) => errors.scope(itemIndex, () => {
+            const resolved = resolve(item);
+            return walkUIItem((resolved ?? item));
+        }));
+    }
+    function walkUIItem(item) {
+        const label = errors.scope('label', () => resolve(item.label) ?? item.label);
+        if (item.type === 'pages') {
+            const innerItems = errors.scope('items', () => {
+                const resolved = resolve(item.items);
+                const resolvedItems = (Array.isArray(resolved) ? resolved : item.items);
+                return walkItems(resolvedItems);
+            });
+            return { ...item, label, items: innerItems };
+        }
+        const inputs = errors.scope('inputs', () => {
+            const resolved = resolve(item.inputs);
+            if (!Array.isArray(resolved)) {
+                return resolved ?? item.inputs;
+            }
+            return walkInputs(resolved);
+        });
+        return { ...item, label, inputs };
+    }
+    function walkInputs(inputs) {
+        return inputs.map((entry, entryIndex) => errors.scope(entryIndex, () => {
+            const resolvedEntry = resolve(entry);
+            return walkInput((resolvedEntry ?? entry));
+        }));
+    }
+    function walkInput(value) {
+        const path = errors.scope('path', () => resolve(value.path) ?? value.path);
+        const displayName = value.displayName &&
+            errors.scope('displayName', () => resolve(value.displayName) ?? value.displayName);
+        const kind = value.kind && errors.scope('kind', () => resolve(value.kind) ?? value.kind);
+        const metadata = value.metadata && errors.scope('metadata', () => walkMetadata(value.metadata));
+        return { ...value, path, displayName, kind, metadata };
+    }
+    function walkMetadata(rawMetadata) {
+        const resolved = resolve(rawMetadata);
+        if (!check.is(BuilderUIInputMetadataSchema, resolved)) {
+            return rawMetadata;
+        }
+        return Object.entries(resolved).reduce((entries, [key, entryValue]) => {
+            const resolvedValue = errors.scope(key, () => resolve(entryValue));
+            return { ...entries, [key]: resolvedValue ?? entryValue };
+        }, {});
+    }
 }
-function walkItems(items, resolve, location) {
-    const errors = [];
-    const result = items.map((item, itemIndex) => {
-        const itemLocation = [...location, itemIndex];
-        const [resolved, resolveErrors] = resolve(item, itemLocation);
-        errors.push(...resolveErrors);
-        const [walked, walkErrors] = walkUIItem((resolved ?? item), resolve, itemLocation);
-        errors.push(...walkErrors);
-        return walked;
+export function checkUIExpectations(mergedModel, ui, errors) {
+    errors.scope('expectations', () => {
+        checkExpectations(mergedModel, ui.expectations, errors);
+    });
+    errors.scope('uis', () => {
+        ui.uis.forEach((nested, nestedIndex) => {
+            errors.scope(nestedIndex, () => {
+                checkUIExpectations(mergedModel, nested, errors);
+            });
+        });
     });
-    return [result, errors];
-}
-function walkUIItem(item, resolve, location) {
-    const errors = [];
-    const [labelValue, labelErrors] = resolve(item.label, [...location, 'label']);
-    errors.push(...labelErrors);
-    const label = labelValue ?? item.label;
-    if (item.type === 'pages') {
-        const [itemsResolved, itemsErrors] = resolve(item.items, [...location, 'items']);
-        errors.push(...itemsErrors);
-        const resolvedItems = (Array.isArray(itemsResolved) ? itemsResolved : item.items);
-        const [innerItems, innerErrors] = walkItems(resolvedItems, resolve, [...location, 'items']);
-        errors.push(...innerErrors);
-        return [{ ...item, label, items: innerItems }, errors];
-    }
-    const [pathsValue, pathsErrors] = resolve(item.paths, [...location, 'paths']);
-    errors.push(...pathsErrors);
-    const paths = pathsValue ?? item.paths;
-    return [{ ...item, label, paths }, errors];
 }

package/dist/validate/variants.d.ts

@@ -1,59 +1,8 @@
 import type { BuilderComponentVariantsValidated, BuilderModelValidated } from '../entities/index';
-import type { BuilderErrorLocation } from '../exception';
-import type { BuilderInstance } from '../instance';
 import type { ValidationResult } from './result';
-export declare function builderErrorMissingComponent(component: string, location?: BuilderErrorLocation): {
-    component: string;
-    kind: "missing-component";
-    location: BuilderErrorLocation;
-};
-export type BuilderErrorMissingComponent = ReturnType<typeof builderErrorMissingComponent>;
-export declare function builderErrorUnexpectedComponent(component: string, location?: BuilderErrorLocation): {
-    component: string;
-    kind: "unexpected-component";
-    location: BuilderErrorLocation;
-};
-export type BuilderErrorUnexpectedComponent = ReturnType<typeof builderErrorUnexpectedComponent>;
-export declare function builderErrorMissingVariant(component: string, instance: BuilderInstance, location?: BuilderErrorLocation): {
-    component: string;
-    instance: BuilderInstance;
-    kind: "missing-variant";
-    location: BuilderErrorLocation;
-};
-export type BuilderErrorMissingVariant = ReturnType<typeof builderErrorMissingVariant>;
-export declare function builderErrorInvalidVariant(component: string, instance: BuilderInstance, location?: BuilderErrorLocation): {
-    component: string;
-    instance: BuilderInstance;
-    kind: "invalid-variant";
-    location: BuilderErrorLocation;
-};
-export type BuilderErrorInvalidVariant = ReturnType<typeof builderErrorInvalidVariant>;
-export declare function builderErrorMissingDetail(component: string, detail: string, instance: BuilderInstance, location?: BuilderErrorLocation): {
-    component: string;
-    detail: string;
-    instance: BuilderInstance;
-    kind: "missing-detail";
-    location: BuilderErrorLocation;
-};
-export type BuilderErrorMissingDetail = ReturnType<typeof builderErrorMissingDetail>;
-export declare function builderErrorUnexpectedDetail(component: string, detail: string, instance: BuilderInstance, location?: BuilderErrorLocation): {
-    component: string;
-    detail: string;
-    instance: BuilderInstance;
-    kind: "unexpected-detail";
-    location: BuilderErrorLocation;
-};
-export type BuilderErrorUnexpectedDetail = ReturnType<typeof builderErrorUnexpectedDetail>;
-export declare function builderErrorInvalidDetail(component: string, detail: string, instance: BuilderInstance, location?: BuilderErrorLocation): {
-    component: string;
-    detail: string;
-    instance: BuilderInstance;
-    kind: "invalid-detail";
-    location: BuilderErrorLocation;
-};
-export type BuilderErrorInvalidDetail = ReturnType<typeof builderErrorInvalidDetail>;
+import { BuilderValidateErrors } from './errors.js';
 export type BuilderVariantsValidationOptions = {
     readonly partial?: boolean;
 };
 export type BuilderComponentVariantsValidationResult = ValidationResult<BuilderComponentVariantsValidated>;
-export declare function validateVariants(model: BuilderModelValidated, input: unknown, options?: BuilderVariantsValidationOptions): BuilderComponentVariantsValidationResult;
+export declare function validateVariants(model: BuilderModelValidated, input: unknown, options?: BuilderVariantsValidationOptions, errors?: BuilderValidateErrors): BuilderComponentVariantsValidationResult;

package/dist/validate/variants.js

@@ -1,100 +1,97 @@
 import { check } from '../check.js';
 import { detailValueSchema } from '../entities/index.js';
-import { builderError } from '../exception.js';
-import { createVariants, resolveComponent } from '../mappers/index.js';
 import { BuilderComponentVariantsSchema } from '../instance.js';
+import { createVariants, resolveComponent } from '../mappers/index.js';
 import { validate } from './brand.js';
-import { builderErrorInvalidInput } from './result.js';
-export function builderErrorMissingComponent(component, location = []) {
-    return { ...builderError('missing-component', location), component };
-}
-export function builderErrorUnexpectedComponent(component, location = []) {
-    return { ...builderError('unexpected-component', location), component };
-}
-export function builderErrorMissingVariant(component, instance, location = []) {
-    return { ...builderError('missing-variant', location), component, instance };
-}
-export function builderErrorInvalidVariant(component, instance, location = []) {
-    return { ...builderError('invalid-variant', location), component, instance };
-}
-export function builderErrorMissingDetail(component, detail, instance, location = []) {
-    return { ...builderError('missing-detail', location), component, detail, instance };
-}
-export function builderErrorUnexpectedDetail(component, detail, instance, location = []) {
-    return { ...builderError('unexpected-detail', location), component, detail, instance };
-}
-export function builderErrorInvalidDetail(component, detail, instance, location = []) {
-    return { ...builderError('invalid-detail', location), component, detail, instance };
-}
-export function validateVariants(model, input, options = {}) {
+import { BuilderValidateErrors } from './errors.js';
+export function validateVariants(model, input, options = {}, errors = new BuilderValidateErrors()) {
     if (!check.is(BuilderComponentVariantsSchema, input)) {
-        const errors = [builderErrorInvalidInput('variants')];
-        return [validate({}), errors];
+        errors.invalidInput('variants');
+        return [validate({}), errors.errors];
     }
+    const variants = input;
     const expected = createVariants(model);
-    const errors = [
-        ...checkVariants(expected, input, options.partial ?? false),
-        ...checkUnexpectedComponents(expected, input),
-        ...checkInvalidDetails(input, model)
-    ];
-    return [validate(input), errors];
-}
-function checkVariants(expected, variants, partial) {
-    return Object.entries(expected).flatMap(([component, expectedVariants]) => {
-        const componentVariants = variants[component];
-        if (componentVariants == null) {
-            return partial ? [] : [builderErrorMissingComponent(component, ['variants'])];
+    errors.scope('variants', () => {
+        checkVariants();
+        checkComponents();
+        checkDetails();
+        function checkVariants() {
+            Object.entries(expected).forEach(([component, expectedVariants]) => {
+                const componentVariants = variants[component];
+                if (componentVariants == null) {
+                    if (options.partial !== false) {
+                        errors.missingComponent(component);
+                    }
+                    return;
+                }
+                errors.scope(component, () => {
+                    const expectedKeys = new Map(expectedVariants.map(({ instance }) => [sortedKey(instance), instance]));
+                    const actualKeys = new Set(componentVariants.map(({ instance }) => sortedKey(instance)));
+                    componentVariants.forEach((variant, index) => {
+                        errors.scope(index, () => {
+                            const { instance } = variant;
+                            if (!expectedKeys.has(sortedKey(instance))) {
+                                errors.invalidVariant(component, instance);
+                            }
+                        });
+                    });
+                    Array.from(expectedKeys).forEach(([key, instance]) => {
+                        if (!actualKeys.has(key)) {
+                            errors.missingVariant(component, instance);
+                        }
+                    });
+                });
+            });
         }
-        const expectedKeys = new Map(expectedVariants.map(({ instance }) => [sortedKey(instance), instance]));
-        const actualKeys = new Set(componentVariants.map(({ instance }) => sortedKey(instance)));
-        return [
-            ...componentVariants
-                .filter(({ instance }) => !expectedKeys.has(sortedKey(instance)))
-                .map((variant) => builderErrorInvalidVariant(component, variant.instance, [
-                'variants',
-                component,
-                componentVariants.indexOf(variant)
-            ])),
-            ...[...expectedKeys]
-                .filter(([key]) => !actualKeys.has(key))
-                .map(([, instance]) => builderErrorMissingVariant(component, instance, ['variants', component]))
-        ];
-    });
-}
-function checkUnexpectedComponents(expected, variants) {
-    return Object.keys(variants)
-        .filter((component) => expected[component] == null)
-        .map((component) => builderErrorUnexpectedComponent(component, ['variants', component]));
-}
-function checkInvalidDetails(variants, model) {
-    const componentByName = new Map(model.components.map((entry) => [entry.name, entry]));
-    return Object.entries(variants).flatMap(([component, componentVariants]) => {
-        const entry = componentByName.get(component);
-        if (entry == null) {
-            return [];
+        function checkComponents() {
+            Object.keys(variants).forEach((component) => {
+                errors.scope(component, () => {
+                    if (expected[component] == null) {
+                        errors.unexpectedComponent(component);
+                    }
+                });
+            });
         }
-        return componentVariants.flatMap(({ instance, details }, index) => {
-            const resolved = resolveComponent(entry, model, instance);
-            const fields = (resolved?.fields ?? []);
-            const expectedNames = new Set(fields.map(({ name }) => name));
-            const actualDetails = details ?? {};
-            const detailsLocation = ['variants', component, index, 'details'];
-            const missingOrInvalid = fields.flatMap(({ name, valueType, isOptional }) => {
-                const detailLocation = [...detailsLocation, name];
-                if (!(name in actualDetails)) {
-                    return [builderErrorMissingDetail(component, name, instance, detailLocation)];
-                }
-                if (!check.is(detailValueSchema(valueType, isOptional), actualDetails[name])) {
-                    return [builderErrorInvalidDetail(component, name, instance, detailLocation)];
-                }
-                return [];
+        function checkDetails() {
+            const componentByName = new Map(model.components.map((entry) => [entry.name, entry]));
+            Object.entries(variants).forEach(([component, componentVariants]) => {
+                errors.scope(component, () => {
+                    const entry = componentByName.get(component);
+                    if (entry == null) {
+                        return;
+                    }
+                    componentVariants.forEach(({ instance, details = {} }, index) => {
+                        errors.scope(index, () => {
+                            const resolved = resolveComponent(entry, model, instance);
+                            const fields = resolved?.fields ?? [];
+                            const expectedNames = new Set(fields.map(({ name }) => name));
+                            errors.scope('details', () => {
+                                fields.forEach(({ name, valueType, isOptional }) => {
+                                    errors.scope(name, () => {
+                                        if (!(name in details)) {
+                                            errors.missingDetail(component, name, instance);
+                                            return;
+                                        }
+                                        if (!check.is(detailValueSchema(valueType, isOptional), details[name])) {
+                                            errors.invalidDetail(component, name, instance);
+                                        }
+                                    });
+                                });
+                                Object.keys(details).forEach((detail) => {
+                                    if (!expectedNames.has(detail)) {
+                                        errors.scope(detail, () => {
+                                            errors.unexpectedDetail(component, detail, instance);
+                                        });
+                                    }
+                                });
+                            });
+                        });
+                    });
+                });
             });
-            const unexpected = Object.keys(actualDetails)
-                .filter((detail) => !expectedNames.has(detail))
-                .map((detail) => builderErrorUnexpectedDetail(component, detail, instance, [...detailsLocation, detail]));
-            return [...missingOrInvalid, ...unexpected];
-        });
+        }
     });
+    return [validate(variants), errors.errors];
 }
 function sortedKey(instance) {
     const entries = Object.entries(instance).filter(([, value]) => value != null);

package/package.json

@@ -1,16 +1,23 @@
 {
   "name": "@builder-builder/builder",
-  "version": "0.0.13",
+  "version": "0.0.15",
   "type": "module",
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
       "default": "./dist/index.js"
+    },
+    "./codegen": {
+      "types": "./dist/codegen/index.d.ts",
+      "default": "./dist/codegen/index.js"
     }
   },
   "files": [
     "dist"
   ],
+  "bin": {
+    "bb": "./dist/cli.js"
+  },
   "svelte": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "publishConfig": {
@@ -33,7 +40,7 @@
     "test": "npm run test:unit -- --run",
     "test:unit": "npm run messages && vitest --project client --project server",
     "test:integration": "npm run messages && vitest run --project integration",
-    "verify": "npm run test && npm run check && npm run format && npm run lint",
+    "verify": "npm run test && npm run check && npm run lint",
     "types:db": "dotenv -e .env.development.local -- supabase gen types typescript --project-id \"$SUPABASE_PROJECT_ID\" --schema public > ./src/lib/db/database.types.ts"
   },
   "devDependencies": {
@@ -62,7 +69,6 @@
     "supabase": "^2.93.0",
     "svelte": "^5.0.0",
     "svelte-check": "^4.0.0",
-    "typescript": "^5.0.0",
     "typescript-eslint": "^8.58.2",
     "vite": "^6.2.6",
     "vitest": "^4.1.5"
@@ -70,6 +76,8 @@
   "dependencies": {
     "@floating-ui/dom": "^1.7.2",
     "@lucide/svelte": "^0.525.0",
+    "@phenomnomnominal/tsquery": "^6.2.0",
+    "@phenomnomnominal/tstemplate": "^0.1.0",
     "@supabase/supabase-js": "^2.104.0",
     "@upstash/ratelimit": "^2.0.5",
     "@upstash/redis": "^1.35.0",
@@ -77,6 +85,7 @@
     "comlink": "^4.4.2",
     "fast-deep-equal": "^3.1.3",
     "svelte-clerk": "^1.1.1",
+    "typescript": "^5.0.0",
     "valibot": "^1.1.0"
   }
 }