@medyll/idae-machine 0.106.0 → 0.108.0

package/README.md

@@ -159,23 +159,37 @@ fields: {
 }
 ```
 
-## 📝 Development Status
 
-⚠️ **Early Development Phase**
+## 🛡️ Robustness & Test Coverage
 
-This package contains foundational code that is:
-- **Partially validated**: Core schema & field system works; form validation in progress
-- **Under active refinement**: API may change as patterns solidify
-- **Proof of concept**: Not recommended for production until v1.0 release
+All core logic in `src/lib/db/dbFields.ts` is now fully schema-driven and covered by comprehensive unit tests (see `src/lib/db/*.spec.ts`).
+
+- **Field parsing**: Handles all types (primitive, array, object, fk) and modifiers (required, readonly, private) with robust string DSL parsing.
+- **Foreign key support**: Correctly parses and exposes fk and reverse-fk relations, with type-safe metadata.
+- **Test-driven**: All exported classes are covered by robust Vitest suites, including edge cases and complex schemas.
+- **Svelte 5 compliance**: All UI code and event handling strictly follow Svelte 5 idioms (see `AGENTS.md`).
 
 ### Current Focus Areas
 - ✅ Schema declaration & type safety
 - ✅ Database integration with idae-idbql
 - ✅ Component exports & library structure
+- ✅ Comprehensive test coverage (dbFields, CRUD, UI)
+- ✅ Svelte 5 event and binding policy
 - 🔄 Form validation (in progress)
 - 🔄 Field rendering pipeline (needs refinement)
 - ⏳ End-to-end CRUD workflows
-- ⏳ Comprehensive test coverage
+
+## 🧪 Testing Policy
+
+All logic in `dbFields.ts` and related modules is covered by unit tests:
+
+- **Test schema**: All tests use a realistic, complex schema (see `testDbSchema.ts`).
+- **Coverage**: Every method of every exported class is tested, including edge cases (array/object/fk/required/readonly).
+- **Continuous validation**: All tests must pass before merge. See `CHANGELOG.md` for test and coverage history.
+
+## 🦄 Svelte 5 Coding Policy
+
+All UI code must strictly follow Svelte 5 syntax and conventions. See `AGENTS.md` for details and migration rules.
 
 ## 🔗 Dependencies
 

package/dist/db/dbFields.d.ts

@@ -38,54 +38,227 @@ export type IDbForge = {
     fieldArgs?: IDbForgeArgs | undefined;
     is: any;
 };
+/**
+ * Central class for parsing, introspecting, and extracting metadata from the database schema.
+ * Provides methods to access collections, templates, fields, foreign keys, and type information.
+ * Used for dynamic UI generation, validation, and schema-driven logic.
+ */
 export declare class IDbCollections {
     #private;
+    /**
+     * The database model (schema) used for introspection.
+     */
     model: IdbqModel;
+    /**
+     * Create a new IDbCollections instance.
+     * @param model Optional custom model to use (default: schemeModel)
+     */
     constructor(model?: IdbqModel);
+    /**
+     * Parse all collections in the model and return their fields as IDbForge objects.
+     * @returns An object mapping collection names to their parsed fields.
+     */
     parseAllCollections(): Record<string, Record<string, IDbForge | undefined> | undefined>;
+    /**
+     * Parse all fields of a given collection.
+     * @param collection The collection name.
+     * @returns An object mapping field names to their IDbForge representation.
+     */
     parseRawCollection(collection: TplCollectionName): Record<string, IDbForge | undefined> | undefined;
+    /**
+     * Parse a single field of a collection and return its IDbForge metadata.
+     * @param collection The collection name.
+     * @param fieldName The field name.
+     * @returns The IDbForge object for the field, or throws if not found.
+     */
     parseCollectionFieldName(collection: TplCollectionName, fieldName: keyof TplFields): IDbForge | undefined;
+    /**
+     * Parse a field rule string and extract its type and arguments.
+     * @param fieldRule The field rule string.
+     * @returns Partial IDbForge info for the rule.
+     */
     parsFieldRule(fieldRule: IDbFieldRules): Partial<IDbForge> | undefined;
+    /**
+     * Internal helper to construct an IDbForge object from its components.
+     * @param params The IDbForge properties (collection, fieldName, fieldType, fieldRule, fieldArgs, is).
+     * @returns The constructed IDbForge object.
+     */
     private forge;
+    /**
+     * Get the collection object from the model.
+     * @param collection The collection name.
+     * @returns The collection object.
+     */
     getCollection(collection: TplCollectionName): CollectionModel;
+    /**
+     * Get the template object for a collection.
+     * @param collection The collection name.
+     * @returns The template object.
+     */
     getCollectionTemplate(collection: TplCollectionName): Tpl;
+    /**
+     * Get the foreign keys (fks) object for a collection.
+     * @param collection The collection name.
+     * @returns The fks object.
+     */
     getCollectionTemplateFks(collection: TplCollectionName): Tpl["fks"];
+    /**
+     * Get the index field name for a collection.
+     * @param collection The collection name.
+     * @returns The index field name.
+     */
     getIndexName(collection: string): string;
+    /**
+     * Get the fields object for a collection.
+     * @param collection The collection name.
+     * @returns The fields object.
+     */
     getCollectionTemplateFields(collection: TplCollectionName): TplFields;
+    /**
+     * Get the presentation string for a collection (used for display).
+     * @param collection The collection name.
+     * @returns The presentation string.
+     */
     getTemplatePresentation(collection: TplCollectionName): string;
+    /**
+     * Get the field rule for a foreign key field (e.g. 'collection.field').
+     * @param string The string in the form 'collection.field'.
+     * @returns The field rule string, or undefined.
+     */
     getFkFieldType(string: `${string}.${string}`): IDbFieldRules | undefined;
+    /**
+     * Get the fields object for a foreign key collection.
+     * @param string The string in the form 'collection.field'.
+     * @returns The fields object for the referenced collection.
+     */
     getFkTemplateFields(string: `${string}.${string}`): {
         [x: string]: import("@medyll/idae-idbql").TplFieldRules;
     };
+    /**
+     * Test if a field rule matches a given type (primitive, array, object, fk).
+     * @param what The type to test ('primitive', 'array', 'object', 'fk').
+     * @param fieldRule The field rule string.
+     * @returns Partial IDbForge info if match, else undefined.
+     */
     private testIs;
+    /**
+     * Extract type information for a field rule.
+     * @param what The type to extract ('primitive', 'array', 'object', 'fk').
+     * @param fieldRule The field rule string.
+     * @returns Partial IDbForge info.
+     */
     is(what: 'array' | 'object' | 'fk' | 'primitive', fieldRule: IDbFieldRules): Partial<IDbForge>;
+    /**
+     * Get the value of the index field for a given data object.
+     * @param collection The collection name.
+     * @param data The data object.
+     * @returns The value of the index field.
+     */
     indexValue(collection: TplCollectionName, data: Record<string, any>): any;
+    /**
+     * Extracts type, rule, and argument information from a field rule string.
+     * @param type The type to extract ('primitive', 'array', 'object', 'fk').
+     * @param fieldRule The field rule string.
+     * @returns Partial IDbForge info.
+     */
     extract(type: 'array' | 'object' | 'fk' | 'primitive', fieldRule: IDbFieldRules): Partial<IDbForge>;
+    /**
+     * Parse and return all foreign key collections referenced by a collection.
+     * @param collection The collection name.
+     * @returns An object mapping referenced collection names to their parsed fields.
+     */
     fks(collection: string): {
         [collection: string]: Tpl;
     };
+    /**
+     * Find all collections that reference the target collection via a foreign key.
+     * @param targetCollection The collection name to search for as a target.
+     * @returns An object mapping referencing collections to their fk configs.
+     */
     reverseFks(targetCollection: TplCollectionName): Record<string, any>;
+    /**
+     * Iterate over an array field and return an array of IDbForge objects for each element.
+     * @param collection The collection name.
+     * @param fieldName The field name.
+     * @param data The array data.
+     * @returns An array of IDbForge objects.
+     */
     iterateArrayField(collection: TplCollectionName, fieldName: keyof TplFields, data: any[]): IDbForge[];
+    /**
+     * Iterate over an object field and return an array of IDbForge objects for each property.
+     * @param collection The collection name.
+     * @param fieldName The field name.
+     * @param data The object data.
+     * @returns An array of IDbForge objects.
+     */
     iterateObjectField(collection: TplCollectionName, fieldName: keyof TplFields, data: Record<string, any>): IDbForge[];
 }
+/**
+ * Utility class to display and format field values for a collection, based on the schema and provided data.
+ * Used for dynamic UI rendering, presentation, and extracting metadata for form generation.
+ * @template T The data type for the collection.
+ */
 export declare class IDbCollectionValues<T extends Record<string, any>> {
     #private;
+    /**
+     * The IDbCollections instance used for schema introspection.
+     */
     dbCollections: IDbCollections;
+    /**
+     * The collection name this instance operates on.
+     */
     private collection;
+    /**
+     * Create a new IDbCollectionValues instance for a given collection.
+     * @param collection The collection name.
+     */
     constructor(collection: TplCollectionName);
     presentation(data: Record<string, any>): string;
+    /**
+     * Get the value of the index field for a data object.
+     * @param data The data object.
+     * @returns The value of the index field, or null if not found.
+     */
     indexValue(data: Record<string, any>): any | null;
+    /**
+     * Format a field value for display, using the field type and schema.
+     * @param fieldName The field name.
+     * @param data The data object.
+     * @returns The formatted value as a string.
+     */
     format(fieldName: keyof T, data: T): string;
+    /**
+     * Get a set of data-* attributes for a field, for use in form generation or UI.
+     * @param fieldName The field name.
+     * @param data The data object.
+     * @returns An object with data-* attributes for the field.
+     */
     getInputDataSet(fieldName: string, data: T): Record<`data-${'collection' | 'collectionId' | 'fieldName' | 'fieldType' | 'fieldArgs'}`, string>;
+    /**
+     * Iterate over an array field and return an array of IDbForge objects for each element.
+     * @param fieldName The field name.
+     * @param data The array data.
+     * @returns An array of IDbForge objects.
+     */
     iterateArrayField(fieldName: keyof TplFields, data: any[]): IDbForge[];
+    /**
+     * Iterate over an object field and return an array of IDbForge objects for each property.
+     * @param fieldName The field name.
+     * @param data The object data.
+     * @returns An array of IDbForge objects.
+     */
     iterateObjectField(fieldName: keyof TplFields, data: Record<string, any>): IDbForge[];
 }
 export declare class IDbCollectionFieldValues<T extends Record<string, any>> {
     #private;
+    /**
+ * Returns the IDbForge metadata for a given field name.
+ * @param fieldName The field name to introspect.
+ */
+    getForge(fieldName: keyof T): IDbForge | undefined;
     constructor(collection: TplCollectionName, data: T);
     format(fieldName: keyof T): string | string[];
     getInputDataSet(fieldName: keyof T): Record<"data-collection" | "data-fieldName" | "data-fieldType" | "data-fieldArgs" | "data-collectionId", string>;
-    getForge(fieldName: keyof T): IDbForge | undefined;
     iterateArray(fieldName: string, data: any[]): IDbForge[];
     iterateObject(fieldName: string, data: Record<string, any>): IDbForge[];
 }
@@ -114,6 +287,12 @@ export declare class IDbFormValidate {
         isValid: boolean;
         error?: string;
     };
+    /**
+     * Validate a single field value for a collection.
+     * @param fieldName The field name.
+     * @param value The value to validate.
+     * @returns True if valid, false otherwise.
+     */
     validateFieldValue(fieldName: keyof TplFields, value: any): boolean;
     validateForm(formData: Record<string, any>, options?: {
         ignoreFields?: string[] | undefined;

package/dist/db/dbFields.js

@@ -46,12 +46,27 @@ class IDbError extends Error {
         }
     }
 }
-// renammed from IDbFields to IDbCollections
+/**
+ * Central class for parsing, introspecting, and extracting metadata from the database schema.
+ * Provides methods to access collections, templates, fields, foreign keys, and type information.
+ * Used for dynamic UI generation, validation, and schema-driven logic.
+ */
 export class IDbCollections {
+    /**
+     * The database model (schema) used for introspection.
+     */
     model = schemeModel;
+    /**
+     * Create a new IDbCollections instance.
+     * @param model Optional custom model to use (default: schemeModel)
+     */
     constructor(model) {
-        this.model = schemeModel; //model ?? this.model;
+        this.model = model ?? schemeModel;
     }
+    /**
+     * Parse all collections in the model and return their fields as IDbForge objects.
+     * @returns An object mapping collection names to their parsed fields.
+     */
     parseAllCollections() {
         let out = {};
         Object.keys(this.model).forEach((collection) => {
@@ -59,6 +74,11 @@ export class IDbCollections {
         });
         return out;
     }
+    /**
+     * Parse all fields of a given collection.
+     * @param collection The collection name.
+     * @returns An object mapping field names to their IDbForge representation.
+     */
     parseRawCollection(collection) {
         const fields = this.getCollectionTemplateFields(collection);
         if (!fields)
@@ -72,18 +92,30 @@ export class IDbCollections {
         });
         return out;
     }
+    /**
+     * Parse a single field of a collection and return its IDbForge metadata.
+     * @param collection The collection name.
+     * @param fieldName The field name.
+     * @returns The IDbForge object for the field, or throws if not found.
+     */
     parseCollectionFieldName(collection, fieldName) {
         const field = this.#getTemplateFieldRule(collection, fieldName);
         if (!field) {
             IDbError.throwError(`Field ${fieldName} not found in collection ${collection}`, 'FIELD_NOT_FOUND');
             return undefined;
         }
-        const fieldType = this.testIs('primitive', field) ??
-            this.testIs('array', field) ??
-            this.testIs('object', field) ??
-            this.testIs('fk', field);
+        const array = this.testIs('array', field);
+        const object = this.testIs('object', field);
+        const fk = this.testIs('fk', field);
+        const primitive = this.testIs('primitive', field);
+        const fieldType = array ?? object ?? fk ?? primitive;
         return this.forge({ collection, fieldName, ...fieldType });
     }
+    /**
+     * Parse a field rule string and extract its type and arguments.
+     * @param fieldRule The field rule string.
+     * @returns Partial IDbForge info for the rule.
+     */
     parsFieldRule(fieldRule) {
         if (!fieldRule)
             return;
@@ -93,6 +125,11 @@ export class IDbCollections {
             this.testIs('fk', fieldRule);
         return fieldType;
     }
+    /**
+     * Internal helper to construct an IDbForge object from its components.
+     * @param params The IDbForge properties (collection, fieldName, fieldType, fieldRule, fieldArgs, is).
+     * @returns The constructed IDbForge object.
+     */
     forge({ collection, fieldName, fieldType, fieldRule, fieldArgs, is }) {
         return {
             collection,
@@ -106,36 +143,82 @@ export class IDbCollections {
     #getModel() {
         return this.model;
     }
+    /**
+     * Get the collection object from the model.
+     * @param collection The collection name.
+     * @returns The collection object.
+     */
     getCollection(collection) {
         return this.#getModel()[String(collection)];
     }
+    /**
+     * Get the template object for a collection.
+     * @param collection The collection name.
+     * @returns The template object.
+     */
     getCollectionTemplate(collection) {
         return this.getCollection(collection)['template'];
     }
+    /**
+     * Get the foreign keys (fks) object for a collection.
+     * @param collection The collection name.
+     * @returns The fks object.
+     */
     getCollectionTemplateFks(collection) {
         return this.getCollection(collection)['template']?.fks;
     }
+    /**
+     * Get the index field name for a collection.
+     * @param collection The collection name.
+     * @returns The index field name.
+     */
     getIndexName(collection) {
         return this.getCollection(collection)?.template?.index;
     }
+    /**
+     * Get the fields object for a collection.
+     * @param collection The collection name.
+     * @returns The fields object.
+     */
     getCollectionTemplateFields(collection) {
         return this.getCollectionTemplate(collection)?.fields;
     }
+    /**
+     * Get the presentation string for a collection (used for display).
+     * @param collection The collection name.
+     * @returns The presentation string.
+     */
     getTemplatePresentation(collection) {
         return this.getCollectionTemplate(collection)?.presentation;
     }
     #getTemplateFieldRule(collection, fieldName) {
         return this.getCollectionTemplateFields(collection)?.[String(fieldName)];
     }
+    /**
+     * Get the field rule for a foreign key field (e.g. 'collection.field').
+     * @param string The string in the form 'collection.field'.
+     * @returns The field rule string, or undefined.
+     */
     getFkFieldType(string) {
         const [collection, field] = string.split('.');
         let template = this.#getTemplateFieldRule(collection, field);
         return template;
     }
+    /**
+     * Get the fields object for a foreign key collection.
+     * @param string The string in the form 'collection.field'.
+     * @returns The fields object for the referenced collection.
+     */
     getFkTemplateFields(string) {
         const [collection, field] = string.split('.');
         return this.getCollection(collection).template?.fields;
     }
+    /**
+     * Test if a field rule matches a given type (primitive, array, object, fk).
+     * @param what The type to test ('primitive', 'array', 'object', 'fk').
+     * @param fieldRule The field rule string.
+     * @returns Partial IDbForge info if match, else undefined.
+     */
     testIs(what, fieldRule) {
         const typeMappings = {
             fk: 'fk-',
@@ -144,18 +227,45 @@ export class IDbCollections {
             primitive: ''
         };
         const prefix = typeMappings[what];
+        if (what === 'primitive') {
+            // Un type primitif ne doit pas commencer par un préfixe array/object/fk
+            if (!fieldRule.startsWith('array-of-') &&
+                !fieldRule.startsWith('object-') &&
+                !fieldRule.startsWith('fk-')) {
+                return this.is(what, fieldRule);
+            }
+            return undefined;
+        }
         if (fieldRule.startsWith(prefix)) {
             return this.is(what, fieldRule);
         }
         return undefined;
     }
+    /**
+     * Extract type information for a field rule.
+     * @param what The type to extract ('primitive', 'array', 'object', 'fk').
+     * @param fieldRule The field rule string.
+     * @returns Partial IDbForge info.
+     */
     is(what, fieldRule) {
         return this.extract(what, fieldRule);
     }
+    /**
+     * Get the value of the index field for a given data object.
+     * @param collection The collection name.
+     * @param data The data object.
+     * @returns The value of the index field.
+     */
     indexValue(collection, data) {
         let presentation = this.getIndexName(collection);
         return data[presentation];
     }
+    /**
+     * Extracts type, rule, and argument information from a field rule string.
+     * @param type The type to extract ('primitive', 'array', 'object', 'fk').
+     * @param fieldRule The field rule string.
+     * @returns Partial IDbForge info.
+     */
     extract(type, fieldRule) {
         // fieldType
         function extractAfter(pattern, source) {
@@ -186,7 +296,8 @@ export class IDbCollections {
                 is = is ?? fieldType;
                 break;
             case 'fk':
-                fieldType = this.getFkFieldType(extractAfter('fk-', fieldRule));
+                // Pour les fk, fieldType doit rester la string d'origine (ex: 'fk-agentPrompt.id')
+                fieldType = 'fk-' + extractAfter('fk-', fieldRule);
                 is = extractedArgs?.piece;
                 break;
             case 'primitive':
@@ -196,6 +307,11 @@ export class IDbCollections {
         }
         return { fieldType, fieldRule, fieldArgs, is: type };
     }
+    /**
+     * Parse and return all foreign key collections referenced by a collection.
+     * @param collection The collection name.
+     * @returns An object mapping referenced collection names to their parsed fields.
+     */
     fks(collection) {
         let fks = this.getCollectionTemplateFks(collection);
         let out = {};
@@ -207,6 +323,11 @@ export class IDbCollections {
         }
         return out;
     }
+    /**
+     * Find all collections that reference the target collection via a foreign key.
+     * @param targetCollection The collection name to search for as a target.
+     * @returns An object mapping referencing collections to their fk configs.
+     */
     reverseFks(targetCollection) {
         const result = {};
         Object.entries(this.#getModel()).forEach(([collectionName, collectionModel]) => {
@@ -225,27 +346,61 @@ export class IDbCollections {
         return result;
     }
     // iterate base
+    /**
+     * Iterate over an array field and return an array of IDbForge objects for each element.
+     * @param collection The collection name.
+     * @param fieldName The field name.
+     * @param data The array data.
+     * @returns An array of IDbForge objects.
+     */
     iterateArrayField(collection, fieldName, data) {
         const fieldInfo = this.parseCollectionFieldName(collection, fieldName);
         if (fieldInfo?.is !== 'array' || !Array.isArray(data)) {
             return [];
         }
-        return data.map(() => this.parseCollectionFieldName(collection, fieldName));
+        // Retourne un tableau d'objets IDbForge génériques pour chaque élément
+        return data.map((_, idx) => ({
+            ...fieldInfo,
+            fieldName: `${String(fieldName)}[${idx}]`,
+        }));
     }
+    /**
+     * Iterate over an object field and return an array of IDbForge objects for each property.
+     * @param collection The collection name.
+     * @param fieldName The field name.
+     * @param data The object data.
+     * @returns An array of IDbForge objects.
+     */
     iterateObjectField(collection, fieldName, data) {
         const fieldInfo = this.parseCollectionFieldName(collection, fieldName);
-        if (fieldInfo?.is !== 'object' || typeof data !== 'object') {
+        if (fieldInfo?.is !== 'object' || typeof data !== 'object' || data === null) {
             return [];
         }
-        return Object.keys(data).map((key) => this.parseCollectionFieldName(collection, key));
+        // Retourne un tableau d'objets IDbForge génériques pour chaque clé
+        return Object.keys(data).map((key) => ({
+            ...fieldInfo,
+            fieldName: `${String(fieldName)}.${key}`,
+        }));
     }
 }
-// display field values, based on schema and provided data
-// renamed from iDBFieldValues to iDbCollectionValues
-// path D:\boulot\python\wollama\src\lib\db\dbFields.ts
+/**
+ * Utility class to display and format field values for a collection, based on the schema and provided data.
+ * Used for dynamic UI rendering, presentation, and extracting metadata for form generation.
+ * @template T The data type for the collection.
+ */
 export class IDbCollectionValues {
+    /**
+     * The IDbCollections instance used for schema introspection.
+     */
     dbCollections;
+    /**
+     * The collection name this instance operates on.
+     */
     collection;
+    /**
+     * Create a new IDbCollectionValues instance for a given collection.
+     * @param collection The collection name.
+     */
     constructor(collection) {
         this.collection = collection;
         this.dbCollections = new IDbCollections();
@@ -268,6 +423,11 @@ export class IDbCollectionValues {
             return '';
         }
     }
+    /**
+     * Get the value of the index field for a data object.
+     * @param data The data object.
+     * @returns The value of the index field, or null if not found.
+     */
     indexValue(data) {
         try {
             this.#checkError(!this.#checkAccess(), 'Access denied', 'ACCESS_DENIED');
@@ -281,6 +441,12 @@ export class IDbCollectionValues {
             return null;
         }
     }
+    /**
+     * Format a field value for display, using the field type and schema.
+     * @param fieldName The field name.
+     * @param data The data object.
+     * @returns The formatted value as a string.
+     */
     format(fieldName, data) {
         try {
             this.#checkError(!this.#checkAccess(), 'Access denied', 'ACCESS_DENIED');
@@ -306,6 +472,12 @@ export class IDbCollectionValues {
             return '';
         }
     }
+    /**
+     * Get a set of data-* attributes for a field, for use in form generation or UI.
+     * @param fieldName The field name.
+     * @param data The data object.
+     * @returns An object with data-* attributes for the field.
+     */
     getInputDataSet(fieldName, data) {
         const fieldInfo = this.dbCollections.parseCollectionFieldName(this.collection, fieldName);
         const fieldType = fieldInfo?.fieldType ?? '';
@@ -319,16 +491,39 @@ export class IDbCollectionValues {
             'data-fieldArgs': fieldArgs
         };
     }
+    /**
+     * Iterate over an array field and return an array of IDbForge objects for each element.
+     * @param fieldName The field name.
+     * @param data The array data.
+     * @returns An array of IDbForge objects.
+     */
     iterateArrayField(fieldName, data) {
         return this.dbCollections.iterateArrayField(this.collection, fieldName, data);
     }
+    /**
+     * Iterate over an object field and return an array of IDbForge objects for each property.
+     * @param fieldName The field name.
+     * @param data The object data.
+     * @returns An array of IDbForge objects.
+     */
     iterateObjectField(fieldName, data) {
         return this.dbCollections.iterateObjectField(this.collection, fieldName, data);
     }
+    /**
+     * Internal: Format a number field for display.
+     * @param value The number value.
+     * @returns The formatted string.
+     */
     #formatNumberField(value) {
         // Implement number formatting logic here
         return value.toString();
     }
+    /**
+     * Internal: Format a text field for display, with length limits by type.
+     * @param value The string value.
+     * @param type The text type (e.g. 'text-short').
+     * @returns The formatted string.
+     */
     #formatTextField(value, type) {
         const lengths = {
             'text-tiny': 10,
@@ -340,10 +535,20 @@ export class IDbCollectionValues {
         const maxLength = lengths[type] || value.length;
         return value.substring(0, maxLength);
     }
+    /**
+     * Internal: Check if access is allowed (override for custom logic).
+     * @returns True if access is allowed.
+     */
     #checkAccess() {
         // Implement access check logic here
         return true;
     }
+    /**
+     * Internal: Throw an error if a condition is met.
+     * @param condition The condition to check.
+     * @param message The error message.
+     * @param code The error code.
+     */
     #checkError(condition, message, code) {
         if (condition) {
             IDbError.throwError(message, code);
@@ -354,6 +559,13 @@ export class IDbCollectionFieldValues {
     #collection;
     #collectionValues;
     #data;
+    /**
+ * Returns the IDbForge metadata for a given field name.
+ * @param fieldName The field name to introspect.
+ */
+    getForge(fieldName) {
+        return this.#collectionValues.dbCollections.parseCollectionFieldName(this.#collection, String(fieldName));
+    }
     constructor(collection, data) {
         this.#collection = collection;
         this.#collectionValues = new IDbCollectionValues(collection);
@@ -373,9 +585,9 @@ export class IDbCollectionFieldValues {
         return this.#collectionValues.getInputDataSet(String(fieldName), this.#data);
     }
     // renamed from parseCollectionFieldName
-    getForge(fieldName) {
-        return this.#collectionValues.dbCollections.parseCollectionFieldName(this.#collection, String(fieldName));
-    }
+    // get forge(): IDbForge | undefined {
+    //     return undefined; // Pas de #fieldName dans cette classe, getter non pertinent
+    // }
     iterateArray(fieldName, data) {
         return this.#collectionValues.iterateArrayField(fieldName, data);
     }
@@ -509,14 +721,15 @@ export class IDbFormValidate {
             throw error;
         }
     }
+    /**
+     * Validate a single field value for a collection.
+     * @param fieldName The field name.
+     * @param value The value to validate.
+     * @returns True if valid, false otherwise.
+     */
     validateFieldValue(fieldName, value) {
-        try {
-            this.validateField(fieldName, value);
-            return true;
-        }
-        catch {
-            return false;
-        }
+        const result = this.validateField(fieldName, value);
+        return !!result.isValid;
     }
     validateForm(formData, options = {}) {
         const errors = {};
@@ -604,3 +817,4 @@ export class IDbFormValidate {
         }
     }
 }
+// (fin de fichier)

package/dist/db/testDbSchema.d.ts

@@ -0,0 +1,56 @@
+import type { DBAgent, DbAgentPrompt } from '$types/db';
+import { type IdbqModel } from '@medyll/idae-idbql';
+import type { DbDataModelTs } from './dataModel.js';
+export declare const schemeModelTestDb: {
+    agent: {
+        keyPath: string;
+        model: DBAgent;
+        ts: DBAgent;
+        template: {
+            index: string;
+            presentation: string;
+            fields: {
+                id: string;
+                name: string;
+                code: string;
+                model: string;
+                prompt: string;
+                created_at: string;
+                ia_lock: string;
+                agentPromptId: string;
+                tags: string;
+                meta: string;
+                relatedAgents: string;
+                status: string;
+            };
+            fks: {
+                agentPrompt: {
+                    code: string;
+                    rules: string;
+                    multiple: boolean;
+                };
+            };
+        };
+    };
+    agentPrompt: {
+        keyPath: string;
+        model: DbAgentPrompt;
+        ts: DbAgentPrompt;
+        template: {
+            index: string;
+            presentation: string;
+            fields: {
+                id: string;
+                created_at: string;
+                value: string;
+                name: string;
+                code: string;
+                ia_lock: string;
+            };
+            fks: {};
+        };
+    };
+};
+export declare const schemeModelTest: IdbqModel;
+export type DataModelTestFinal = DbDataModelTs<typeof schemeModelTestDb>;
+export declare const idbql: import("@medyll/idae-idbql").ReadonlyCollections<IdbqModel<Record<string, Record<string, any>>>>, idbqlState: import("@medyll/idae-idbql").StateCollections<IdbqModel<Record<string, Record<string, any>>>>, idbDatabase: import("@medyll/idae-idbql").IdbqlIndexedCore<IdbqModel<Record<string, Record<string, any>>>>, idbqModel: IdbqModel<Record<string, Record<string, any>>>;

package/dist/db/testDbSchema.js

@@ -0,0 +1,58 @@
+import { createIdbqDb } from '@medyll/idae-idbql';
+// Schéma de test (copie explicite de schemeModelDb)
+export const schemeModelTestDb = {
+    agent: {
+        keyPath: '++id, promptId, created_at',
+        model: {},
+        ts: {},
+        template: {
+            index: 'id',
+            presentation: 'name model',
+            fields: {
+                id: 'id (readonly)',
+                name: 'text (private)',
+                code: 'text',
+                model: 'text',
+                prompt: 'text-long',
+                created_at: 'date (private)',
+                ia_lock: 'boolean (private)',
+                agentPromptId: 'fk-agentPrompt.id (required)',
+                tags: 'array-of-text', // array field
+                meta: 'object-any', // object field
+                relatedAgents: 'array-of-fk-agent.id', // fk multiple
+                status: 'text (required readonly)'
+            },
+            fks: {
+                agentPrompt: {
+                    code: 'agentPrompt',
+                    rules: 'readonly private',
+                    multiple: true
+                }
+            }
+        }
+    },
+    agentPrompt: {
+        keyPath: '++id, created_at',
+        model: {},
+        ts: {},
+        template: {
+            index: 'id',
+            presentation: 'name',
+            fields: {
+                id: 'id (readonly)',
+                created_at: 'date (private)',
+                value: 'text-long (required)',
+                name: 'text (required)',
+                code: 'text (required)',
+                ia_lock: 'boolean (private)'
+            },
+            fks: {}
+        }
+    }
+    // Ajoute ici d'autres collections si besoin pour les tests
+};
+export const schemeModelTest = {
+    ...schemeModelTestDb
+};
+const idbqStore = createIdbqDb(schemeModelTest, 99);
+export const { idbql, idbqlState, idbDatabase, idbqModel } = idbqStore.create('idae-machine-test');

package/dist/index.d.ts

@@ -1,3 +1,4 @@
+export * from './machine.js';
 export * from './types/appschemeTypes.js';
 export { default as Skeleton } from './fragments/Skeleton.svelte';
 export { default as Selector } from './fragments/Selector.svelte';
@@ -19,7 +20,14 @@ export { default as CollectionFks } from './form/CollectionFks.svelte';
 export { default as CollectionFieldGuess } from './form/CollectionFieldGuess.svelte';
 export { default as CollectionButton } from './form/CollectionButton.svelte';
 export * from './db/types.js';
+export * from './db/testDbSchema.js';
 export * from './db/dbSchema.js';
+export * from './db/dbSchema.spec.js';
+export * from './db/dbFormValidate.spec.js';
 export * from './db/dbFields.js';
+export * from './db/dbFields.spec.js';
+export * from './db/dbCollectionValues.spec.js';
+export * from './db/dbCollectionFieldValues.spec.js';
+export * from './db/dbCollectionFieldForge.spec.js';
 export * from './db/dataModel.js';
 export * from './db/CrudService.js';

package/dist/index.js

@@ -1,4 +1,5 @@
 // auto exports of entry components
+export * from './machine.js';
 export * from './types/appschemeTypes.js';
 export { default as Skeleton } from './fragments/Skeleton.svelte';
 export { default as Selector } from './fragments/Selector.svelte';
@@ -20,7 +21,14 @@ export { default as CollectionFks } from './form/CollectionFks.svelte';
 export { default as CollectionFieldGuess } from './form/CollectionFieldGuess.svelte';
 export { default as CollectionButton } from './form/CollectionButton.svelte';
 export * from './db/types.js';
+export * from './db/testDbSchema.js';
 export * from './db/dbSchema.js';
+export * from './db/dbSchema.spec.js';
+export * from './db/dbFormValidate.spec.js';
 export * from './db/dbFields.js';
+export * from './db/dbFields.spec.js';
+export * from './db/dbCollectionValues.spec.js';
+export * from './db/dbCollectionFieldValues.spec.js';
+export * from './db/dbCollectionFieldForge.spec.js';
 export * from './db/dataModel.js';
 export * from './db/CrudService.js';

package/dist/machine.d.ts

@@ -0,0 +1,76 @@
+import { IDbCollections } from './db/dbFields.js';
+import { createIdbqDb } from '@medyll/idae-idbql';
+/**
+ * Machine: main entry point for managing the IDBQL connection and centralized data access.
+ */
+export declare class Machine {
+    /**
+  
+     * IDBQL (readonly collections instance)
+     */
+    idbql: ReturnType<ReturnType<typeof createIdbqDb>["create"]>["idbql"] | undefined;
+    /**
+     * IDBQL (stateful collections instance)
+     */
+    idbqlState: ReturnType<ReturnType<typeof createIdbqDb>["create"]>["idbqlState"] | undefined;
+    /**
+     * Direct access to IndexedDB (core)
+     */
+    idbDatabase: ReturnType<ReturnType<typeof createIdbqDb>["create"]>["idbDatabase"] | undefined;
+    /**
+     * IDBQL data model
+     */
+    idbqModel: ReturnType<ReturnType<typeof createIdbqDb>["create"]>["idbqModel"] | undefined;
+    /**
+     * Centralized access to schema and collection logic
+     */
+    collections: IDbCollections | undefined;
+    /**
+     * Database name
+     */
+    dbName: string;
+    /**
+     * Schema version
+     */
+    version: number;
+    /**
+     * Data model
+     */
+    model: any;
+    /**
+     * Main constructor
+     * @param dbName Database name (default: 'idae-machine')
+     * @param version Schema version (default: 1)
+     * @param model Data model (default: schemeModel)
+     */
+    constructor(dbName?: string, version?: number, model?: import("@medyll/idae-idbql").IdbqModel<Record<string, Record<string, any>>>);
+    /**
+     * Start the machine: initialize collections and IDBQL connection.
+     * @param options Optional overrides: { dbName, version, model }
+     */
+    start(options?: {
+        dbName?: string;
+        version?: number;
+        model?: any;
+    }): void;
+    /**
+     * Get the IDbCollections (schema logic) instance
+     */
+    getCollections(): IDbCollections | undefined;
+    /**
+     * Get the IDBQL (readonly) instance
+     */
+    getIdbql(): import("@medyll/idae-idbql").ReadonlyCollections<import("@medyll/idae-idbql").IdbqModel<Record<string, Record<string, any>>>> | undefined;
+    /**
+     * Get the IDBQL (stateful) instance
+     */
+    getIdbqlState(): import("@medyll/idae-idbql").StateCollections<import("@medyll/idae-idbql").IdbqModel<Record<string, Record<string, any>>>> | undefined;
+    /**
+     * Get the IndexedDB (core) instance
+     */
+    getIdbDatabase(): import("@medyll/idae-idbql").IdbqlIndexedCore<import("@medyll/idae-idbql").IdbqModel<Record<string, Record<string, any>>>> | undefined;
+    /**
+     * Get the IDBQL data model instance
+     */
+    getIdbqModel(): import("@medyll/idae-idbql").IdbqModel<Record<string, Record<string, any>>> | undefined;
+}

package/dist/machine.js

@@ -0,0 +1,129 @@
+/**
+ * Example usage:
+ *
+ * import { Machine } from './machine.js';
+ *
+ * // Create a new Machine instance with default parameters
+ * const machine = new Machine();
+ *
+ * // Start the machine (initialize collections and IDBQL connection)
+ * machine.start();
+ *
+ * // Access collections (schema logic)
+ * const collections = machine.getCollections();
+ *
+ * // Access IDBQL (readonly)
+ * const idbql = machine.getIdbql();
+ *
+ * // Access IDBQL (stateful)
+ * const idbqlState = machine.getIdbqlState();
+ *
+ * // Access IndexedDB core
+ * const db = machine.getIdbDatabase();
+ *
+ * // Access the IDBQL data model
+ * const model = machine.getIdbqModel();
+ */
+import { schemeModel } from './db/dbSchema.js';
+import { IDbCollections } from './db/dbFields.js';
+import { createIdbqDb } from '@medyll/idae-idbql';
+/**
+ * Machine: main entry point for managing the IDBQL connection and centralized data access.
+ */
+export class Machine {
+    /**
+  
+     * IDBQL (readonly collections instance)
+     */
+    idbql;
+    /**
+     * IDBQL (stateful collections instance)
+     */
+    idbqlState;
+    /**
+     * Direct access to IndexedDB (core)
+     */
+    idbDatabase;
+    /**
+     * IDBQL data model
+     */
+    idbqModel;
+    /**
+     * Centralized access to schema and collection logic
+     */
+    collections;
+    /**
+     * Database name
+     */
+    dbName;
+    /**
+     * Schema version
+     */
+    version;
+    /**
+     * Data model
+     */
+    model;
+    /**
+     * Main constructor
+     * @param dbName Database name (default: 'idae-machine')
+     * @param version Schema version (default: 1)
+     * @param model Data model (default: schemeModel)
+     */
+    constructor(dbName = 'idae-machine', version = 1, model = schemeModel) {
+        this.dbName = dbName;
+        this.version = version;
+        this.model = model;
+        this.collections = undefined;
+        this.idbql = undefined;
+        this.idbqlState = undefined;
+        this.idbDatabase = undefined;
+        this.idbqModel = undefined;
+    }
+    /**
+     * Start the machine: initialize collections and IDBQL connection.
+     * @param options Optional overrides: { dbName, version, model }
+     */
+    start(options) {
+        const dbName = options?.dbName ?? this.dbName;
+        const version = options?.version ?? this.version;
+        const model = options?.model ?? this.model;
+        this.collections = new IDbCollections(model);
+        const idbqStore = createIdbqDb(model, version);
+        const { idbql, idbqlState, idbDatabase, idbqModel } = idbqStore.create(dbName);
+        this.idbql = idbql;
+        this.idbqlState = idbqlState;
+        this.idbDatabase = idbDatabase;
+        this.idbqModel = idbqModel;
+    }
+    /**
+     * Get the IDbCollections (schema logic) instance
+     */
+    getCollections() {
+        return this.collections;
+    }
+    /**
+     * Get the IDBQL (readonly) instance
+     */
+    getIdbql() {
+        return this.idbql;
+    }
+    /**
+     * Get the IDBQL (stateful) instance
+     */
+    getIdbqlState() {
+        return this.idbqlState;
+    }
+    /**
+     * Get the IndexedDB (core) instance
+     */
+    getIdbDatabase() {
+        return this.idbDatabase;
+    }
+    /**
+     * Get the IDBQL data model instance
+     */
+    getIdbqModel() {
+        return this.idbqModel;
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@medyll/idae-machine",
-	"version": "0.106.0",
+	"version": "0.108.0",
 	"scripts": {
 		"dev": "vite dev",
 		"build": "vite build && npm run prepack",