@stonecrop/stonecrop 0.10.16 → 0.11.0

package/dist/src/plugins/index.js

@@ -0,0 +1,96 @@
+import { nextTick } from 'vue';
+import Registry from '../registry';
+import { Stonecrop } from '../stonecrop';
+import { useOperationLogStore } from '../stores/operation-log';
+/**
+ * Setup auto-initialization for user-defined initialization logic
+ * This function handles the post-mount initialization automatically
+ */
+async function setupAutoInitialization(registry, stonecrop, onRouterInitialized) {
+    // Wait for the next tick to ensure the app is mounted
+    await nextTick();
+    try {
+        await onRouterInitialized(registry, stonecrop);
+    }
+    catch {
+        // Silent error handling - application should handle initialization errors
+    }
+}
+/**
+ * Stonecrop Vue plugin
+ * @param app - The Vue app instance
+ * @param options - The plugin options
+ * @example
+ * ```ts
+ * import { createApp } from 'vue'
+ * import Stonecrop from '@stonecrop/stonecrop'
+ * import { StonecropClient } from '@stonecrop/graphql-client'
+ * import router from './router'
+ *
+ * const client = new StonecropClient({ endpoint: '/graphql' })
+ *
+ * const app = createApp(App)
+ * app.use(Stonecrop, {
+ *   router,
+ *   client,
+ *   getMeta: async (routeContext) => {
+ *     // routeContext contains: { path, segments }
+ *     // use the client to fetch doctype meta
+ *     return client.getMeta({ doctype: routeContext.segments[0] })
+ *   },
+ *   autoInitializeRouter: true,
+ *   onRouterInitialized: async (registry, stonecrop) => {
+ *     // your custom initialization logic here
+ *   }
+ * })
+ * app.mount('#app')
+ * ```
+ * @public
+ */
+const plugin = {
+    install: (app, options) => {
+        // Check for existing router installation
+        const existingRouter = app.config.globalProperties.$router;
+        const providedRouter = options?.router;
+        const router = existingRouter || providedRouter;
+        if (!existingRouter && providedRouter) {
+            app.use(providedRouter);
+        }
+        // Create registry with available router
+        const registry = new Registry(router, options?.getMeta);
+        app.provide('$registry', registry);
+        app.config.globalProperties.$registry = registry;
+        // Create and provide a global Stonecrop instance
+        const stonecrop = new Stonecrop(registry, undefined, options?.client ? { client: options.client } : undefined);
+        app.provide('$stonecrop', stonecrop);
+        app.config.globalProperties.$stonecrop = stonecrop;
+        // Initialize operation log store if Pinia is available
+        // This ensures the store is created with the app's Pinia instance
+        try {
+            const pinia = app.config.globalProperties.$pinia;
+            if (pinia) {
+                // Initialize the operation log store with the app's Pinia instance
+                const operationLogStore = useOperationLogStore(pinia);
+                // Provide the store so components can access it
+                app.provide('$operationLogStore', operationLogStore);
+                app.config.globalProperties.$operationLogStore = operationLogStore;
+            }
+        }
+        catch (error) {
+            // Pinia not available - operation log won't work, but app should still function
+            // eslint-disable-next-line no-console
+            console.warn('Pinia not available - operation log features will be disabled:', error);
+        }
+        // Register custom components
+        if (options?.components) {
+            for (const [tag, component] of Object.entries(options.components)) {
+                app.component(tag, component);
+            }
+        }
+        // Setup auto-initialization if requested
+        if (options?.autoInitializeRouter && options.onRouterInitialized) {
+            void setupAutoInitialization(registry, stonecrop, options.onRouterInitialized);
+        }
+    },
+};
+export default plugin;

package/dist/src/registry.d.ts

@@ -1,4 +1,5 @@
 import type { SchemaTypes } from '@stonecrop/aform';
+import type { DoctypeMeta, LinkDeclaration } from '@stonecrop/schema';
 import { Router } from 'vue-router';
 import Doctype from './doctype';
 import { RouteContext } from './types/registry';
@@ -19,9 +20,27 @@ export default class Registry {
     readonly name: string;
     /**
      * The registry property contains a collection of doctypes
+     *
+     * @defaultValue `{}`
      * @see {@link Doctype}
      */
     readonly registry: Record<string, Doctype>;
+    /**
+     * Reverse index: backlink fieldname → list of \{ doctype slug, link fieldname \}.
+     * Multiple doctypes can declare a link with the same backlink name, so each key
+     * maps to an array. Built at schema load time for O(1) ancestor lookups.
+     *
+     * @defaultValue `new Map()`
+     * @internal
+     */
+    private _ancestorIndex;
+    /**
+     * Whether the ancestor index needs rebuilding
+     *
+     * @defaultValue `true`
+     * @internal
+     */
+    private _ancestorIndexDirty;
     /**
      * The Vue router instance
      * @see {@link https://router.vuejs.org/}
@@ -48,35 +67,32 @@ export default class Registry {
     /**
      * Resolve nested Doctype fields in a schema by embedding child schemas inline.
      *
-     * @remarks
-     * Walks the schema array and for each field with `fieldtype: 'Doctype'` and a string
-     * `options` value, looks up the referenced doctype in the registry and:
+     * Accepts a Doctype and extracts `fields` and `links` internally.
+     * Fields array contains both scalar fields and link fields (with fieldtype: 'Link').
+     * Render order is determined by the order of fields in the fields array.
      *
-     * - If `cardinality: 'many'`: auto-derives `columns` from the child doctype's schema,
-     *   sets `component: 'ATable'`, `config: { view: 'list' }`, and initializes `rows: []`.
-     * - Otherwise (default/`cardinality: 'one'`): embeds the child schema as the field's
-     *   `schema` property for 1:1 nested forms.
+     * For each link field:
+     * - Looks up the corresponding link declaration in `links` by fieldname
+     * - `cardinality: 'noneOrMany'` or `'atLeastOne'`: auto-derives `columns` from the target's schema,
+     *   sets `component` to `link.component ?? 'ATable'`, `config: { view: 'list' }`, `rows: []`.
+     * - `cardinality: 'one'` or `'atMostOne'`: embeds the target schema as the entry's
+     *   `schema` property, sets `component` to `link.component ?? 'AForm'`.
      *
      * Recurses for deeply nested doctypes. Circular references are protected against.
+     * Returns a new array — does not mutate the original.
      *
-     * Returns a new array — does not mutate the original schema.
-     *
-     * @param schema - The schema array to resolve
-     * @returns A new schema array with nested Doctype fields resolved
-     *
-     * @example
-     * ```ts
-     * registry.addDoctype(addressDoctype)
-     * registry.addDoctype(customerDoctype)
-     *
-     * // Before: customer schema has { fieldname: 'address', fieldtype: 'Doctype', options: 'address' }
-     * const resolved = registry.resolveSchema(customerSchema)
-     * // After: address field now has schema: [...address fields...]
-     * ```
+     * @param doctype - The doctype to resolve
+     * @param visited - Internal — set of already-visited doctype slugs for cycle detection
+     * @returns A new schema array with nested links resolved
      *
      * @public
      */
-    resolveSchema(schema: SchemaTypes[], visited?: Set<string>): SchemaTypes[];
+    resolveSchema(doctype: Doctype, visited?: Set<string>): SchemaTypes[];
+    /**
+     * Build an ATable configuration from a field and child schema
+     * @internal
+     */
+    private buildTableConfig;
     /**
      * Initialize a new record with default values based on a schema.
      *
@@ -87,7 +103,7 @@ export default class Registry {
      * - Check → `false`
      * - Int, Float, Decimal, Currency, Quantity → `0`
      * - JSON → `{}`
-     * - Doctype with `cardinality: 'many'` → `[]`
+     * - Doctype with `cardinality: 'noneOrMany'` or `'atLeastOne'` → `[]`
      * - Doctype without `cardinality` or `cardinality: 'one'` → recursively initializes nested record
      * - All others → `null`
      *
@@ -113,5 +129,68 @@ export default class Registry {
      * @public
      */
     getDoctype(slug: string): Doctype | undefined;
+    /**
+     * Get all links declared on a doctype.
+     *
+     * @param doctypeSlug - The doctype slug to get links for
+     * @returns Array of link declarations with fieldname, or empty array if none
+     *
+     * @example
+     * ```ts
+     * const links = registry.getDescendantLinks('recipe')
+     * // [{ fieldname: 'tasks', target: 'recipe-task', cardinality: 'noneOrMany', backlink: 'recipe' }]
+     * ```
+     *
+     * @public
+     */
+    getDescendantLinks(doctypeSlug: string): Array<LinkDeclaration & {
+        fieldname: string;
+    }>;
+    /**
+     * Get links on other doctypes that target the given doctype.
+     *
+     * @param doctypeSlug - The doctype slug to find ancestor links for
+     * @returns Array of link declarations with fieldname and declaring doctype slug, or empty array
+     *
+     * @example
+     * ```ts
+     * const ancestors = registry.getAncestorLinks('recipe-task')
+     * // [{ fieldname: 'tasks', target: 'recipe-task', cardinality: 'noneOrMany', backlink: 'recipe', doctype: 'recipe' }]
+     * ```
+     *
+     * @public
+     */
+    getAncestorLinks(doctypeSlug: string): Array<LinkDeclaration & {
+        fieldname: string;
+        doctype: string;
+    }>;
+    /**
+     * Ensure the ancestor index is up to date
+     * @internal
+     */
+    private _ensureAncestorIndex;
+    /**
+     * Convert the registry to a Map of DoctypeMeta objects for use with StonecropClient.
+     *
+     * This allows passing a Registry instance to StonecropClient by deriving the
+     * Map\<string, DoctypeMeta\> that StonecropClient needs for building nested GraphQL queries.
+     *
+     * @returns Map of doctype metadata keyed by doctype name
+     *
+     * @example
+     * ```typescript
+     * const registry = new Registry()
+     * registry.addDoctype(Doctype.fromObject(customerSchema))
+     * registry.addDoctype(Doctype.fromObject(orderSchema))
+     *
+     * const client = new StonecropClient({
+     *   endpoint: '/graphql',
+     *   registry: registry.toMetaMap(),  // Convert once, use with client
+     * })
+     * ```
+     *
+     * @public
+     */
+    toMetaMap(): Map<string, DoctypeMeta>;
 }
 //# sourceMappingURL=registry.d.ts.map

package/dist/src/registry.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../src/registry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAA;AACnD,OAAO,EAAE,MAAM,EAAE,MAAM,YAAY,CAAA;AAEnC,OAAO,OAAO,MAAM,WAAW,CAAA;AAE/B,OAAO,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAA;AAE/C;;;GAGG;AACH,MAAM,CAAC,OAAO,OAAO,QAAQ;IAC5B;;OAEG;IACH,MAAM,CAAC,KAAK,EAAE,QAAQ,CAAA;IAEtB;;;;OAIG;IACH,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IAErB;;;OAGG;IACH,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IAE1C;;;OAGG;IACH,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAA;IAExB;;;;OAIG;gBACS,MAAM,CAAC,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,CAAC,YAAY,EAAE,YAAY,KAAK,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC;IAWjG;;;OAGG;IACH,OAAO,CAAC,EAAE,CAAC,YAAY,EAAE,YAAY,KAAK,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,CAAA;IAEpE;;;;;OAKG;IACH,UAAU,CAAC,OAAO,EAAE,OAAO;IAsB3B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA8BG;IACH,aAAa,CAAC,MAAM,EAAE,WAAW,EAAE,EAAE,OAAO,CAAC,EAAE,GAAG,CAAC,MAAM,CAAC,GAAG,WAAW,EAAE;IA4E1E;;;;;;;;;;;;;;;;;;;;;;;;;;;OA2BG;IACH,gBAAgB,CAAC,MAAM,EAAE,WAAW,EAAE,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;IAgD5D;;;;;OAKG;IACH,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,GAAG,SAAS;CAgB7C"}
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../src/registry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAe,MAAM,kBAAkB,CAAA;AAChE,OAAO,KAAK,EAAE,WAAW,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAA;AACrE,OAAO,EAAE,MAAM,EAAE,MAAM,YAAY,CAAA;AAEnC,OAAO,OAAO,MAAM,WAAW,CAAA;AAE/B,OAAO,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAA;AAE/C;;;GAGG;AACH,MAAM,CAAC,OAAO,OAAO,QAAQ;IAC5B;;OAEG;IACH,MAAM,CAAC,KAAK,EAAE,QAAQ,CAAA;IAEtB;;;;OAIG;IACH,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAa;IAElC;;;;;OAKG;IACH,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAK;IAE/C;;;;;;;OAOG;IACH,OAAO,CAAC,cAAc,CAAqE;IAE3F;;;;;OAKG;IACH,OAAO,CAAC,mBAAmB,CAAgB;IAE3C;;;OAGG;IACH,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAA;IAExB;;;;OAIG;gBACS,MAAM,CAAC,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,CAAC,YAAY,EAAE,YAAY,KAAK,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC;IASjG;;;OAGG;IACH,OAAO,CAAC,EAAE,CAAC,YAAY,EAAE,YAAY,KAAK,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,CAAA;IAEpE;;;;;OAKG;IACH,UAAU,CAAC,OAAO,EAAE,OAAO;IAuB3B;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,aAAa,CAAC,OAAO,EAAE,OAAO,EAAE,OAAO,CAAC,EAAE,GAAG,CAAC,MAAM,CAAC,GAAG,WAAW,EAAE;IA6ErE;;;OAGG;IACH,OAAO,CAAC,gBAAgB;IAiCxB;;;;;;;;;;;;;;;;;;;;;;;;;;;OA2BG;IACH,gBAAgB,CAAC,MAAM,EAAE,WAAW,EAAE,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;IAoD5D;;;;;OAKG;IACH,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,GAAG,SAAS;IAI7C;;;;;;;;;;;;;OAaG;IACH,kBAAkB,CAAC,WAAW,EAAE,MAAM,GAAG,KAAK,CAAC,eAAe,GAAG;QAAE,SAAS,EAAE,MAAM,CAAA;KAAE,CAAC;IAUvF;;;;;;;;;;;;;OAaG;IACH,gBAAgB,CAAC,WAAW,EAAE,MAAM,GAAG,KAAK,CAAC,eAAe,GAAG;QAAE,SAAS,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,CAAC;IAwBtG;;;OAGG;IACH,OAAO,CAAC,oBAAoB;IAoB5B;;;;;;;;;;;;;;;;;;;;;OAqBG;IACH,SAAS,IAAI,GAAG,CAAC,MAAM,EAAE,WAAW,CAAC;CA4BrC"}

package/dist/src/registry.js

@@ -0,0 +1,246 @@
+import { getGlobalTriggerEngine } from './field-triggers';
+/**
+ * Stonecrop Registry class
+ * @public
+ */
+export default class Registry {
+    /**
+     * The root Registry instance
+     */
+    static _root;
+    /**
+     * The name of the Registry instance
+     *
+     * @defaultValue 'Registry'
+     */
+    name = 'Registry';
+    /**
+     * The registry property contains a collection of doctypes
+     * @see {@link Doctype}
+     */
+    registry = {};
+    /**
+     * The Vue router instance
+     * @see {@link https://router.vuejs.org/}
+     */
+    router;
+    /**
+     * Creates a new Registry instance (singleton pattern)
+     * @param router - Optional Vue router instance for route management
+     * @param getMeta - Optional function to fetch doctype metadata from an API
+     */
+    constructor(router, getMeta) {
+        if (Registry._root) {
+            return Registry._root;
+        }
+        Registry._root = this;
+        this.router = router;
+        this.getMeta = getMeta;
+    }
+    /**
+     * The getMeta function fetches doctype metadata from an API based on route context
+     * @see {@link Doctype}
+     */
+    getMeta;
+    /**
+     * Get doctype metadata
+     * @param doctype - The doctype to fetch metadata for
+     * @returns The doctype metadata
+     * @see {@link Doctype}
+     */
+    addDoctype(doctype) {
+        if (!(doctype.slug in this.registry)) {
+            this.registry[doctype.slug] = doctype;
+        }
+        // Register actions (including field triggers) with the field trigger engine
+        const triggerEngine = getGlobalTriggerEngine();
+        // Register under both doctype name and slug to handle different lookup patterns
+        triggerEngine.registerDoctypeActions(doctype.doctype, doctype.actions);
+        if (doctype.slug !== doctype.doctype) {
+            triggerEngine.registerDoctypeActions(doctype.slug, doctype.actions);
+        }
+        if (doctype.component && this.router && !this.router.hasRoute(doctype.doctype)) {
+            this.router.addRoute({
+                path: `/${doctype.slug}`,
+                name: doctype.slug,
+                component: doctype.component,
+            });
+        }
+    }
+    /**
+     * Resolve nested Doctype fields in a schema by embedding child schemas inline.
+     *
+     * @remarks
+     * Walks the schema array and for each field with `fieldtype: 'Doctype'` and a string
+     * `options` value, looks up the referenced doctype in the registry and:
+     *
+     * - If `cardinality: 'many'`: auto-derives `columns` from the child doctype's schema,
+     *   sets `component: 'ATable'`, `config: { view: 'list' }`, and initializes `rows: []`.
+     * - Otherwise (default/`cardinality: 'one'`): embeds the child schema as the field's
+     *   `schema` property for 1:1 nested forms.
+     *
+     * Recurses for deeply nested doctypes. Circular references are protected against.
+     *
+     * Returns a new array — does not mutate the original schema.
+     *
+     * @param schema - The schema array to resolve
+     * @returns A new schema array with nested Doctype fields resolved
+     *
+     * @example
+     * ```ts
+     * registry.addDoctype(addressDoctype)
+     * registry.addDoctype(customerDoctype)
+     *
+     * // Before: customer schema has { fieldname: 'address', fieldtype: 'Doctype', options: 'address' }
+     * const resolved = registry.resolveSchema(customerSchema)
+     * // After: address field now has schema: [...address fields...]
+     * ```
+     *
+     * @public
+     */
+    resolveSchema(schema, visited) {
+        const seen = visited || new Set();
+        return schema.map(field => {
+            // Check for Doctype fieldtype with a string options (slug reference)
+            if ('fieldtype' in field &&
+                field.fieldtype === 'Doctype' &&
+                'options' in field &&
+                typeof field.options === 'string') {
+                const doctypeSlug = field.options;
+                // Circular reference protection
+                if (seen.has(doctypeSlug)) {
+                    return { ...field };
+                }
+                const doctype = this.registry[doctypeSlug];
+                if (doctype && doctype.schema) {
+                    // Convert Immutable.List to plain array if needed
+                    const childSchema = Array.isArray(doctype.schema) ? doctype.schema : Array.from(doctype.schema);
+                    // Check cardinality to determine handling
+                    const cardinality = 'cardinality' in field ? field.cardinality : undefined;
+                    if (cardinality === 'many') {
+                        // 1:many child table - derive columns, set component, config, rows
+                        const resolved = { ...field };
+                        // Auto-derive columns from child schema fields if not already provided
+                        if (!('columns' in field) || !field.columns) {
+                            resolved.columns = childSchema.map(childField => ({
+                                name: childField.fieldname,
+                                fieldname: childField.fieldname,
+                                label: ('label' in childField && childField.label) || childField.fieldname,
+                                fieldtype: 'fieldtype' in childField ? childField.fieldtype : 'Data',
+                                align: ('align' in childField && childField.align) || 'left',
+                                edit: 'edit' in childField ? childField.edit : true,
+                                width: ('width' in childField && childField.width) || '20ch',
+                            }));
+                        }
+                        // Set default component if not already specified
+                        if (!resolved.component) {
+                            resolved.component = 'ATable';
+                        }
+                        // Set default config if not already specified
+                        if (!('config' in field) || !field.config) {
+                            resolved.config = { view: 'list' };
+                        }
+                        // Initialize rows to empty array so componentProps fallback
+                        // routes data from the form's dataModel[fieldname]
+                        if (!('rows' in field) || !field.rows) {
+                            resolved.rows = [];
+                        }
+                        return resolved;
+                    }
+                    else {
+                        // 1:1 nested form (default cardinality: 'one')
+                        // Recurse into child schema to resolve deeply nested doctypes
+                        seen.add(doctypeSlug);
+                        const resolvedChild = this.resolveSchema(childSchema, seen);
+                        seen.delete(doctypeSlug);
+                        return { ...field, schema: resolvedChild };
+                    }
+                }
+            }
+            return { ...field };
+        });
+    }
+    /**
+     * Initialize a new record with default values based on a schema.
+     *
+     * @remarks
+     * Creates a plain object with keys from the schema's fieldnames and default values
+     * derived from each field's `fieldtype`:
+     * - Data, Text → `''`
+     * - Check → `false`
+     * - Int, Float, Decimal, Currency, Quantity → `0`
+     * - JSON → `{}`
+     * - Doctype with `cardinality: 'many'` → `[]`
+     * - Doctype without `cardinality` or `cardinality: 'one'` → recursively initializes nested record
+     * - All others → `null`
+     *
+     * For Doctype fields with a resolved `schema` array (cardinality: 'one'), recursively
+     * initializes the nested record.
+     *
+     * @param schema - The schema array to derive defaults from
+     * @returns A plain object with default values for each field
+     *
+     * @example
+     * ```ts
+     * const defaults = registry.initializeRecord(addressSchema)
+     * // { street: '', city: '', state: '', zip_code: '' }
+     * ```
+     *
+     * @public
+     */
+    initializeRecord(schema) {
+        const record = {};
+        schema.forEach(field => {
+            const fieldtype = 'fieldtype' in field ? field.fieldtype : 'Data';
+            switch (fieldtype) {
+                case 'Data':
+                case 'Text':
+                case 'Code':
+                    record[field.fieldname] = '';
+                    break;
+                case 'Check':
+                    record[field.fieldname] = false;
+                    break;
+                case 'Int':
+                case 'Float':
+                case 'Decimal':
+                case 'Currency':
+                case 'Quantity':
+                    record[field.fieldname] = 0;
+                    break;
+                case 'JSON':
+                    record[field.fieldname] = {};
+                    break;
+                case 'Doctype': {
+                    // Check cardinality to determine initial value
+                    const cardinality = 'cardinality' in field ? field.cardinality : undefined;
+                    if (cardinality === 'many') {
+                        // 1:many child table - initialize as empty array
+                        record[field.fieldname] = [];
+                    }
+                    else if ('schema' in field && Array.isArray(field.schema)) {
+                        // 1:1 nested form with resolved schema - recursively initialize
+                        record[field.fieldname] = this.initializeRecord(field.schema);
+                    }
+                    else {
+                        // 1:1 without resolved schema - empty object
+                        record[field.fieldname] = {};
+                    }
+                    break;
+                }
+                default:
+                    record[field.fieldname] = null;
+            }
+        });
+        return record;
+    }
+    /**
+     * Get a registered doctype by slug
+     * @param slug - The doctype slug to look up
+     * @returns The Doctype instance if found, or undefined
+     * @public
+     */
+    getDoctype(slug) {
+        return this.registry[slug];
+    }
+}

package/dist/src/schema-validator.d.ts

@@ -4,6 +4,7 @@
  * @packageDocumentation
  */
 import type { SchemaTypes } from '@stonecrop/aform';
+import type { LinkDeclaration } from '@stonecrop/schema';
 import type { List, Map as ImmutableMap } from 'immutable';
 import type { AnyStateNodeConfig } from 'xstate';
 import type Registry from './registry';
@@ -25,9 +26,10 @@ export declare class SchemaValidator {
      * @param schema - Schema fields (List or Array)
      * @param workflow - Optional workflow configuration
      * @param actions - Optional actions map
+     * @param links - Optional links object
      * @returns Validation result
      */
-    validate(doctype: string, schema: List<SchemaTypes> | SchemaTypes[] | undefined, workflow?: AnyStateNodeConfig, actions?: ImmutableMap<string, string[]> | Map<string, string[]>): ValidationResult;
+    validate(doctype: string, schema: List<SchemaTypes> | SchemaTypes[] | undefined, workflow?: AnyStateNodeConfig, actions?: ImmutableMap<string, string[]> | Map<string, string[]>, links?: Record<string, LinkDeclaration>): ValidationResult;
     /**
      * Validates that required schema properties are present
      * @internal
@@ -38,6 +40,11 @@ export declare class SchemaValidator {
      * @internal
      */
     private validateLinkFields;
+    /**
+     * Validates link declarations: target resolution, backlink consistency, Link field correspondence
+     * @internal
+     */
+    private validateLinkDeclarations;
     /**
      * Validates workflow state machine configuration
      * @internal

package/dist/src/schema-validator.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"schema-validator.d.ts","sourceRoot":"","sources":["../../src/schema-validator.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAA;AACnD,OAAO,KAAK,EAAE,IAAI,EAAE,GAAG,IAAI,YAAY,EAAE,MAAM,WAAW,CAAA;AAC1D,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,QAAQ,CAAA;AAGhD,OAAO,KAAK,QAAQ,MAAM,YAAY,CAAA;AAEtC,OAAO,KAAK,EAAmB,gBAAgB,EAAE,gBAAgB,EAAE,MAAM,0BAA0B,CAAA;AAEnG;;;GAGG;AACH,qBAAa,eAAe;IAC3B,OAAO,CAAC,OAAO,CAA4B;IAE3C;;;OAGG;gBACS,OAAO,GAAE,gBAAqB;IAU1C;;;;;;;OAOG;IACH,QAAQ,CACP,OAAO,EAAE,MAAM,EACf,MAAM,EAAE,IAAI,CAAC,WAAW,CAAC,GAAG,WAAW,EAAE,GAAG,SAAS,EACrD,QAAQ,CAAC,EAAE,kBAAkB,EAC7B,OAAO,CAAC,EAAE,YAAY,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,GAAG,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,GAC9D,gBAAgB;IAyCnB;;;OAGG;IACH,OAAO,CAAC,0BAA0B;IAwClC;;;OAGG;IACH,OAAO,CAAC,kBAAkB;IA4D1B;;;OAGG;IACH,OAAO,CAAC,gBAAgB;IAmFxB;;;OAGG;IACH,OAAO,CAAC,0BAA0B;CAuClC;AAED;;;;;;GAMG;AACH,wBAAgB,eAAe,CAAC,QAAQ,EAAE,QAAQ,EAAE,OAAO,CAAC,EAAE,OAAO,CAAC,gBAAgB,CAAC,GAAG,eAAe,CAKxG;AAED;;;;;;;;;GASG;AACH,wBAAgB,cAAc,CAC7B,OAAO,EAAE,MAAM,EACf,MAAM,EAAE,IAAI,CAAC,WAAW,CAAC,GAAG,WAAW,EAAE,GAAG,SAAS,EACrD,QAAQ,EAAE,QAAQ,EAClB,QAAQ,CAAC,EAAE,kBAAkB,EAC7B,OAAO,CAAC,EAAE,YAAY,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,GAAG,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,GAC9D,gBAAgB,CAGlB"}
+{"version":3,"file":"schema-validator.d.ts","sourceRoot":"","sources":["../../src/schema-validator.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAA;AACnD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAA;AACxD,OAAO,KAAK,EAAE,IAAI,EAAE,GAAG,IAAI,YAAY,EAAE,MAAM,WAAW,CAAA;AAC1D,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,QAAQ,CAAA;AAGhD,OAAO,KAAK,QAAQ,MAAM,YAAY,CAAA;AAEtC,OAAO,KAAK,EAAmB,gBAAgB,EAAE,gBAAgB,EAAE,MAAM,0BAA0B,CAAA;AAEnG;;;GAGG;AACH,qBAAa,eAAe;IAC3B,OAAO,CAAC,OAAO,CAA4B;IAE3C;;;OAGG;gBACS,OAAO,GAAE,gBAAqB;IAW1C;;;;;;;;OAQG;IACH,QAAQ,CACP,OAAO,EAAE,MAAM,EACf,MAAM,EAAE,IAAI,CAAC,WAAW,CAAC,GAAG,WAAW,EAAE,GAAG,SAAS,EACrD,QAAQ,CAAC,EAAE,kBAAkB,EAC7B,OAAO,CAAC,EAAE,YAAY,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,GAAG,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,EAChE,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,eAAe,CAAC,GACrC,gBAAgB;IA8CnB;;;OAGG;IACH,OAAO,CAAC,0BAA0B;IAwClC;;;OAGG;IACH,OAAO,CAAC,kBAAkB;IA4D1B;;;OAGG;IACH,OAAO,CAAC,wBAAwB;IA0GhC;;;OAGG;IACH,OAAO,CAAC,gBAAgB;IAmFxB;;;OAGG;IACH,OAAO,CAAC,0BAA0B;CAuClC;AAED;;;;;;GAMG;AACH,wBAAgB,eAAe,CAAC,QAAQ,EAAE,QAAQ,EAAE,OAAO,CAAC,EAAE,OAAO,CAAC,gBAAgB,CAAC,GAAG,eAAe,CAKxG;AAED;;;;;;;;;GASG;AACH,wBAAgB,cAAc,CAC7B,OAAO,EAAE,MAAM,EACf,MAAM,EAAE,IAAI,CAAC,WAAW,CAAC,GAAG,WAAW,EAAE,GAAG,SAAS,EACrD,QAAQ,EAAE,QAAQ,EAClB,QAAQ,CAAC,EAAE,kBAAkB,EAC7B,OAAO,CAAC,EAAE,YAAY,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,GAAG,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,GAC9D,gBAAgB,CAGlB"}