@medyll/idae-machine 0.111.0 → 0.112.0

package/README.md

@@ -42,8 +42,10 @@ export const schemeModel = {
 Après avoir instancié et démarré Machine :
 
 ```typescript
-import { Machine, schemeModel } from '@medyll/idae-machine';
-const machine = new Machine('my-db', 1, schemeModel);
+import { machine, schemeModel } from '@medyll/idae-machine';
+
+// Initialisation du singleton
+machine.init({ dbName: 'my-db', version: 1, model: schemeModel });
 machine.start();
 
 // Ajouter un agent
@@ -174,15 +176,15 @@ IndexedDB Abstraction (@medyll/idae-idbql)
 
 The recommended way to initialize your app is to use the `Machine` class, which centralizes schema, collections, and IndexedDB access.
 
+
 ```typescript
-import { Machine } from '@medyll/idae-machine';
-import { schemeModel } from '@medyll/idae-machine'; // Or your own model
+import { machine, schemeModel } from '@medyll/idae-machine';
 
-// Create and start the machine
-const machine = new Machine('my-db', 1, schemeModel);
+// Initialisation du singleton
+machine.init({ dbName: 'my-db', version: 1, model: schemeModel });
 machine.start();
 
-// Access collections, database, and models
+// Accès aux collections, à la base et au modèle
 const collections = machine.collections;
 const idbql = machine.idbql;
 const idbqlState = machine.idbqlState;

package/dist/db/dbFields.d.ts

@@ -38,6 +38,28 @@ export type IDbForge = {
     fieldArgs?: IDbForgeArgs | undefined;
     is: any;
 };
+export declare class IDbCollection {
+    collection: TplCollectionName;
+    _dbCollections: IDbCollections;
+    constructor(collection: TplCollectionName, dbCollections: IDbCollections);
+    getCollectionModelTemplate(): Tpl;
+    getCollectionModelTemplateFks(): {
+        [x: string]: {
+            code: string;
+            multiple: boolean;
+            rules: import("@medyll/idae-idbql").CombinedArgs;
+        } | undefined;
+    };
+    getIndexName(): string;
+    collectionValues(): IDbCollectionValues<any>;
+    collectionFieldValues<T extends Record<string, any>>(data: T): IDbCollectionFieldValues<T>;
+    fieldForge<T extends Record<string, any>>(fieldName: keyof T, data: T): IDbCollectionFieldForge<T>;
+    getFormValidate(): IDbFormValidate;
+    fks(): {
+        [collection: string]: Tpl;
+    };
+    reverseFks(): Record<string, 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.
@@ -45,6 +67,22 @@ export type IDbForge = {
  */
 export declare class IDbCollections {
     #private;
+    /**
+     * Stores shared instances of IDbCollectionValues per collection
+     */
+    private _collectionValuesMap;
+    /**
+     * Stores shared instances of IDbCollectionFieldValues per collection+data
+     */
+    private _collectionFieldValuesMap;
+    /**
+     * Stores shared instances of IDbCollectionFieldForge per collection, field, and data
+     */
+    private _collectionFieldForgeMap;
+    /**
+     * Stores shared instances of IDbFormValidate per collection
+     */
+    private _formValidateMap;
     /**
      * The database model (schema) used for introspection.
      */
@@ -54,6 +92,7 @@ export declare class IDbCollections {
      * @param model Optional custom model to use (default: schemeModel)
      */
     constructor(model?: IdbqModel);
+    get(collection: TplCollectionName): IDbCollection;
     /**
      * Parse all collections in the model and return their fields as IDbForge objects.
      * @returns An object mapping collection names to their parsed fields.
@@ -89,25 +128,48 @@ export declare class IDbCollections {
      * @param collection The collection name.
      * @returns The collection object.
      */
-    getCollection(collection: TplCollectionName): CollectionModel;
+    getCollection(collection: TplCollectionName): CollectionModel; /**
+     * Get the collection object from the model.
+     * @param collection The collection name.
+     * @returns The collection object.
+     */
+    getCollectionModel(collection: TplCollectionName): CollectionModel;
     /**
      * Get the template object for a collection.
      * @param collection The collection name.
      * @returns The template object.
      */
-    getCollectionTemplate(collection: TplCollectionName): Tpl;
+    getCollectionModelTemplate(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"];
+    getCollectionModelTemplateFks(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;
+    getIndexName(collection: TplCollectionName): string;
+    /**
+     * Returns a shared instance of IDbCollectionValues for a given collection
+     */
+    getCollectionValues(collection: TplCollectionName): IDbCollectionValues<any>;
+    /**
+     * Returns a shared instance of IDbCollectionFieldValues for a given collection and data
+     * The instance key is based on the collection and the main index of data (or JSON if missing)
+     */
+    getCollectionFieldValues<T extends Record<string, any>>(collection: TplCollectionName, data: T): IDbCollectionFieldValues<T>;
+    /**
+     * Returns a shared instance of IDbCollectionFieldForge for a given collection, field, and data
+     * The instance key is based on collection, field, and the main index of data (or JSON if missing)
+     */
+    getCollectionFieldForge<T extends Record<string, any>>(collection: TplCollectionName, fieldName: keyof T | string, data: T): IDbCollectionFieldForge<T>;
+    /**
+     * Returns a shared instance of IDbFormValidate for a given collection
+     */
+    getFormValidate(collection: TplCollectionName): IDbFormValidate;
     /**
      * Get the fields object for a collection.
      * @param collection The collection name.
@@ -194,25 +256,44 @@ export declare class IDbCollections {
     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.
+ * IDbCollectionValues
+ *
+ * This class provides utilities to display, format, and introspect field values for a given collection, using the schema and provided data.
+ * It is designed for dynamic UI rendering, presentation logic, and metadata extraction for form generation in schema-driven applications.
+ *
+ * Main responsibilities:
+ * - Holds a reference to the collection name and the schema (IDbCollections).
+ * - Provides methods to format field values according to their type (number, text, array, object, etc.).
+ * - Supplies presentation logic for displaying records (e.g., presentation string, index value).
+ * - Offers input attribute generation for forms (inputDataSet).
+ * - Supports iteration over array/object fields for advanced UI layouts.
+ * - Enables access to field metadata for validation and rendering.
+ *
+ * Usage:
+ *   const values = new IDbCollectionValues('agents');
+ *   const display = values.presentation(agentData); // formatted display string
+ *   const index = values.indexValue(agentData); // index field value
+ *   const formatted = values.format('name', agentData); // formatted field value
+ *   const attrs = values.getInputDataSet('name', agentData); // input attributes for forms
+ *
+ * This class is typically used via IDbCollections.getCollectionValues for shared instance management.
+ * @template T - The type of the data object for the collection.
  */
 export declare class IDbCollectionValues<T extends Record<string, any>> {
     #private;
     /**
      * The IDbCollections instance used for schema introspection.
      */
-    dbCollections: IDbCollections;
+    idbCollections: IDbCollections;
     /**
      * The collection name this instance operates on.
      */
-    private collection;
+    private collectionName;
     /**
      * Create a new IDbCollectionValues instance for a given collection.
-     * @param collection The collection name.
+     * @param collectionName The collection name.
      */
-    constructor(collection: TplCollectionName);
+    constructor(collectionName: TplCollectionName, idbCollections?: IDbCollections);
     presentation(data: Record<string, any>): string;
     /**
      * Get the value of the index field for a data object.
@@ -256,15 +337,37 @@ export declare class IDbCollectionFieldValues<T extends Record<string, any>> {
  * @param fieldName The field name to introspect.
  */
     getForge(fieldName: keyof T): IDbForge | undefined;
-    constructor(collection: TplCollectionName, data: T);
+    constructor(collection: TplCollectionName, data: T, collectionValues?: IDbCollectionValues<T>);
     format(fieldName: keyof T): string | string[];
     getInputDataSet(fieldName: keyof T): Record<"data-collection" | "data-fieldName" | "data-fieldType" | "data-fieldArgs" | "data-collectionId", string>;
     iterateArray(fieldName: string, data: any[]): IDbForge[];
     iterateObject(fieldName: string, data: Record<string, any>): IDbForge[];
 }
+/**
+ * IDbCollectionFieldForge
+ *
+ * This class provides advanced metadata and formatting for a single field of a collection, given a data object.
+ * It is designed for dynamic UI generation, form rendering, and introspection in schema-driven applications.
+ *
+ * Main responsibilities:
+ * - Holds references to the collection name, field name, and the data object for context.
+ * - Provides access to the parsed field metadata (IDbForge) for the field, including type, rules, and arguments.
+ * - Offers formatting utilities for the field value, adapting to type (number, text, array, object, etc.).
+ * - Supplies input attributes and type hints for form generation (e.g., htmlInputType, inputDataSet).
+ * - Supports iteration over array/object fields for complex form layouts.
+ * - Enables extraction of raw data and field arguments for validation and UI logic.
+ *
+ * Usage:
+ *   const forge = new IDbCollectionFieldForge('agents', 'name', agentData);
+ *   const formatted = forge.format; // formatted value for display
+ *   const inputType = forge.htmlInputType; // e.g. 'text', 'area', 'email', etc.
+ *   const meta = forge.forge; // IDbForge metadata for the field
+ *
+ * This class is typically used via IDbCollections.getCollectionFieldForge for shared instance management.
+ */
 export declare class IDbCollectionFieldForge<T extends Record<string, any>> {
     #private;
-    constructor(collection: TplCollectionName, fieldName: any, data: T);
+    constructor(collection: TplCollectionName, fieldName: any, data: T, collectionValues?: IDbCollectionValues<T>);
     get format(): string;
     get inputDataSet(): Record<"data-collection" | "data-fieldName" | "data-fieldType" | "data-fieldArgs" | "data-collectionId", string>;
     get forge(): IDbForge | undefined;
@@ -281,8 +384,8 @@ export declare class IDbCollectionFieldForge<T extends Record<string, any>> {
 export declare class IDbFormValidate {
     #private;
     private collection;
-    private dbFields;
-    constructor(collection: TplCollectionName);
+    private idbCollections;
+    constructor(collection: TplCollectionName, idbCollections?: IDbCollections);
     validateField(fieldName: keyof TplFields, value: any): {
         isValid: boolean;
         error?: string;

package/dist/db/dbFields.js

@@ -46,12 +46,64 @@ class IDbError extends Error {
         }
     }
 }
+/* Single collection relies on IDbCollections */
+export class IDbCollection {
+    collection;
+    _dbCollections;
+    constructor(collection, dbCollections) {
+        this.collection = collection;
+        this._dbCollections = dbCollections;
+    }
+    getCollectionModelTemplate() {
+        return this._dbCollections.getCollectionModelTemplate(this.collection);
+    }
+    getCollectionModelTemplateFks() {
+        return this._dbCollections.getCollectionModelTemplateFks(this.collection);
+    }
+    getIndexName() {
+        return this._dbCollections.getIndexName(this.collection);
+    }
+    collectionValues() {
+        return this._dbCollections.getCollectionValues(this.collection);
+    }
+    collectionFieldValues(data) {
+        return this._dbCollections.getCollectionFieldValues(this.collection, data);
+    }
+    fieldForge(fieldName, data) {
+        return this._dbCollections.getCollectionFieldForge(this.collection, fieldName, data);
+    }
+    getFormValidate() {
+        return this._dbCollections.getFormValidate(this.collection);
+    }
+    fks() {
+        return this._dbCollections.fks(this.collection);
+    }
+    reverseFks() {
+        return this._dbCollections.reverseFks(this.collection);
+    }
+}
 /**
  * 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 {
+    /**
+     * Stores shared instances of IDbCollectionValues per collection
+     */
+    _collectionValuesMap = {};
+    /**
+     * Stores shared instances of IDbCollectionFieldValues per collection+data
+     */
+    _collectionFieldValuesMap = new Map();
+    /**
+     * Stores shared instances of IDbCollectionFieldForge per collection, field, and data
+     */
+    _collectionFieldForgeMap = new Map();
+    /**
+     * Stores shared instances of IDbFormValidate per collection
+     */
+    _formValidateMap = new Map();
     /**
      * The database model (schema) used for introspection.
      */
@@ -63,6 +115,9 @@ export class IDbCollections {
     constructor(model) {
         this.model = model ?? schemeModel;
     }
+    get(collection) {
+        return new IDbCollection(collection, this);
+    }
     /**
      * Parse all collections in the model and return their fields as IDbForge objects.
      * @returns An object mapping collection names to their parsed fields.
@@ -83,7 +138,7 @@ export class IDbCollections {
         const fields = this.getCollectionTemplateFields(collection);
         if (!fields)
             return;
-        let out = {};
+        const out = {};
         Object.keys(fields).forEach((fieldName) => {
             const fieldType = fields[fieldName];
             if (fieldType) {
@@ -150,22 +205,29 @@ export class IDbCollections {
      */
     getCollection(collection) {
         return this.#getModel()[String(collection)];
+    } /**
+     * Get the collection object from the model.
+     * @param collection The collection name.
+     * @returns The collection object.
+     */
+    getCollectionModel(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'];
+    getCollectionModelTemplate(collection) {
+        return this.getCollectionModel(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;
+    getCollectionModelTemplateFks(collection) {
+        return this.getCollectionModel(collection)['template']?.fks;
     }
     /**
      * Get the index field name for a collection.
@@ -173,7 +235,51 @@ export class IDbCollections {
      * @returns The index field name.
      */
     getIndexName(collection) {
-        return this.getCollection(collection)?.template?.index;
+        return this.getCollectionModel(collection)?.template?.index;
+    }
+    /**
+     * Returns a shared instance of IDbCollectionValues for a given collection
+     */
+    getCollectionValues(collection) {
+        if (!this._collectionValuesMap[collection]) {
+            this._collectionValuesMap[collection] = new IDbCollectionValues(collection, this);
+        }
+        return this._collectionValuesMap[collection];
+    }
+    /**
+     * Returns a shared instance of IDbCollectionFieldValues for a given collection and data
+     * The instance key is based on the collection and the main index of data (or JSON if missing)
+     */
+    getCollectionFieldValues(collection, data) {
+        const indexName = this.getIndexName(collection);
+        const indexValue = data?.[indexName];
+        const key = `${collection}:${indexValue ?? JSON.stringify(data)}`;
+        if (!this._collectionFieldValuesMap.has(key)) {
+            this._collectionFieldValuesMap.set(key, new IDbCollectionFieldValues(collection, data, this.getCollectionValues(collection)));
+        }
+        return this._collectionFieldValuesMap.get(key);
+    }
+    /**
+     * Returns a shared instance of IDbCollectionFieldForge for a given collection, field, and data
+     * The instance key is based on collection, field, and the main index of data (or JSON if missing)
+     */
+    getCollectionFieldForge(collection, fieldName, data) {
+        const indexName = this.getIndexName(collection);
+        const indexValue = data?.[indexName];
+        const key = `${collection}:${String(fieldName)}:${indexValue ?? JSON.stringify(data)}`;
+        if (!this._collectionFieldForgeMap.has(key)) {
+            this._collectionFieldForgeMap.set(key, new IDbCollectionFieldForge(collection, fieldName, data, this.getCollectionValues(collection)));
+        }
+        return this._collectionFieldForgeMap.get(key);
+    }
+    /**
+     * Returns a shared instance of IDbFormValidate for a given collection
+     */
+    getFormValidate(collection) {
+        if (!this._formValidateMap.has(collection)) {
+            this._formValidateMap.set(collection, new IDbFormValidate(collection, this));
+        }
+        return this._formValidateMap.get(collection);
     }
     /**
      * Get the fields object for a collection.
@@ -181,7 +287,7 @@ export class IDbCollections {
      * @returns The fields object.
      */
     getCollectionTemplateFields(collection) {
-        return this.getCollectionTemplate(collection)?.fields;
+        return this.getCollectionModelTemplate(collection)?.fields;
     }
     /**
      * Get the presentation string for a collection (used for display).
@@ -189,7 +295,7 @@ export class IDbCollections {
      * @returns The presentation string.
      */
     getTemplatePresentation(collection) {
-        return this.getCollectionTemplate(collection)?.presentation;
+        return this.getCollectionModelTemplate(collection)?.presentation;
     }
     #getTemplateFieldRule(collection, fieldName) {
         return this.getCollectionTemplateFields(collection)?.[String(fieldName)];
@@ -211,7 +317,7 @@ export class IDbCollections {
      */
     getFkTemplateFields(string) {
         const [collection, field] = string.split('.');
-        return this.getCollection(collection).template?.fields;
+        return this.getCollectionModel(collection).template?.fields;
     }
     /**
      * Test if a field rule matches a given type (primitive, array, object, fk).
@@ -384,31 +490,50 @@ export class IDbCollections {
     }
 }
 /**
- * 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.
+ * IDbCollectionValues
+ *
+ * This class provides utilities to display, format, and introspect field values for a given collection, using the schema and provided data.
+ * It is designed for dynamic UI rendering, presentation logic, and metadata extraction for form generation in schema-driven applications.
+ *
+ * Main responsibilities:
+ * - Holds a reference to the collection name and the schema (IDbCollections).
+ * - Provides methods to format field values according to their type (number, text, array, object, etc.).
+ * - Supplies presentation logic for displaying records (e.g., presentation string, index value).
+ * - Offers input attribute generation for forms (inputDataSet).
+ * - Supports iteration over array/object fields for advanced UI layouts.
+ * - Enables access to field metadata for validation and rendering.
+ *
+ * Usage:
+ *   const values = new IDbCollectionValues('agents');
+ *   const display = values.presentation(agentData); // formatted display string
+ *   const index = values.indexValue(agentData); // index field value
+ *   const formatted = values.format('name', agentData); // formatted field value
+ *   const attrs = values.getInputDataSet('name', agentData); // input attributes for forms
+ *
+ * This class is typically used via IDbCollections.getCollectionValues for shared instance management.
+ * @template T - The type of the data object for the collection.
  */
 export class IDbCollectionValues {
     /**
      * The IDbCollections instance used for schema introspection.
      */
-    dbCollections;
+    idbCollections;
     /**
      * The collection name this instance operates on.
      */
-    collection;
+    collectionName;
     /**
      * Create a new IDbCollectionValues instance for a given collection.
-     * @param collection The collection name.
+     * @param collectionName The collection name.
      */
-    constructor(collection) {
-        this.collection = collection;
-        this.dbCollections = new IDbCollections();
+    constructor(collectionName, idbCollections) {
+        this.collectionName = collectionName;
+        this.idbCollections = idbCollections ?? new IDbCollections();
     }
     presentation(data) {
         try {
             this.#checkError(!this.#checkAccess(), 'Access denied', 'ACCESS_DENIED');
-            const presentation = this.dbCollections.getTemplatePresentation(this.collection);
+            const presentation = this.idbCollections.getTemplatePresentation(this.collectionName);
             this.#checkError(!presentation, 'Presentation template not found', 'TEMPLATE_NOT_FOUND');
             const fields = presentation.split(' ');
             return fields
@@ -431,7 +556,7 @@ export class IDbCollectionValues {
     indexValue(data) {
         try {
             this.#checkError(!this.#checkAccess(), 'Access denied', 'ACCESS_DENIED');
-            const indexName = this.dbCollections.getIndexName(this.collection);
+            const indexName = this.idbCollections.getIndexName(this.collectionName);
             this.#checkError(!indexName, 'Index not found for collection', 'INDEX_NOT_FOUND');
             this.#checkError(!(indexName in data), `Index field ${indexName} not found in data`, 'FIELD_NOT_FOUND');
             return data[indexName];
@@ -451,7 +576,7 @@ export class IDbCollectionValues {
         try {
             this.#checkError(!this.#checkAccess(), 'Access denied', 'ACCESS_DENIED');
             this.#checkError(!(fieldName in data), `Field ${String(fieldName)} not found in data`, 'FIELD_NOT_FOUND');
-            const fieldInfo = this.dbCollections.parseCollectionFieldName(this.collection, fieldName);
+            const fieldInfo = this.idbCollections.parseCollectionFieldName(this.collectionName, fieldName);
             this.#checkError(!fieldInfo, `Field ${String(fieldName)} not found in collection`, 'FIELD_NOT_FOUND');
             switch (fieldInfo?.fieldType) {
                 case 'number':
@@ -479,12 +604,12 @@ export class IDbCollectionValues {
      * @returns An object with data-* attributes for the field.
      */
     getInputDataSet(fieldName, data) {
-        const fieldInfo = this.dbCollections.parseCollectionFieldName(this.collection, fieldName);
+        const fieldInfo = this.idbCollections.parseCollectionFieldName(this.collectionName, fieldName);
         const fieldType = fieldInfo?.fieldType ?? '';
         const fieldArgs = fieldInfo?.fieldArgs?.join(' ') ?? '';
-        const indexName = this.dbCollections.getIndexName(this.collection);
+        const indexName = this.idbCollections.getIndexName(this.collectionName);
         return {
-            'data-collection': this.collection,
+            'data-collection': this.collectionName,
             'data-collectionId': indexName && data?.[indexName] !== undefined ? String(data?.[indexName]) : '',
             'data-fieldName': String(fieldName),
             'data-fieldType': fieldType,
@@ -498,7 +623,7 @@ export class IDbCollectionValues {
      * @returns An array of IDbForge objects.
      */
     iterateArrayField(fieldName, data) {
-        return this.dbCollections.iterateArrayField(this.collection, fieldName, data);
+        return this.idbCollections.iterateArrayField(this.collectionName, fieldName, data);
     }
     /**
      * Iterate over an object field and return an array of IDbForge objects for each property.
@@ -507,7 +632,7 @@ export class IDbCollectionValues {
      * @returns An array of IDbForge objects.
      */
     iterateObjectField(fieldName, data) {
-        return this.dbCollections.iterateObjectField(this.collection, fieldName, data);
+        return this.idbCollections.iterateObjectField(this.collectionName, fieldName, data);
     }
     /**
      * Internal: Format a number field for display.
@@ -564,15 +689,15 @@ export class IDbCollectionFieldValues {
  * @param fieldName The field name to introspect.
  */
     getForge(fieldName) {
-        return this.#collectionValues.dbCollections.parseCollectionFieldName(this.#collection, String(fieldName));
+        return this.#collectionValues.idbCollections.parseCollectionFieldName(this.#collection, String(fieldName));
     }
-    constructor(collection, data) {
+    constructor(collection, data, collectionValues) {
         this.#collection = collection;
-        this.#collectionValues = new IDbCollectionValues(collection);
+        this.#collectionValues = collectionValues ?? new IDbCollectionValues(collection);
         this.#data = data;
     }
     format(fieldName) {
-        const fieldInfo = this.#collectionValues.dbCollections.parseCollectionFieldName(this.#collection, fieldName);
+        const fieldInfo = this.#collectionValues.idbCollections.parseCollectionFieldName(this.#collection, fieldName);
         if (fieldInfo?.is === 'array') {
             return this.iterateArray(String(fieldName), this.#data);
         }
@@ -595,9 +720,27 @@ export class IDbCollectionFieldValues {
         return this.#collectionValues.iterateObjectField(fieldName, data);
     }
 }
-/*
-    path: D:\boulot\python\wollama\src\lib\db\dbFields.ts
-    forge values for a collection field and $data
+/**
+ * IDbCollectionFieldForge
+ *
+ * This class provides advanced metadata and formatting for a single field of a collection, given a data object.
+ * It is designed for dynamic UI generation, form rendering, and introspection in schema-driven applications.
+ *
+ * Main responsibilities:
+ * - Holds references to the collection name, field name, and the data object for context.
+ * - Provides access to the parsed field metadata (IDbForge) for the field, including type, rules, and arguments.
+ * - Offers formatting utilities for the field value, adapting to type (number, text, array, object, etc.).
+ * - Supplies input attributes and type hints for form generation (e.g., htmlInputType, inputDataSet).
+ * - Supports iteration over array/object fields for complex form layouts.
+ * - Enables extraction of raw data and field arguments for validation and UI logic.
+ *
+ * Usage:
+ *   const forge = new IDbCollectionFieldForge('agents', 'name', agentData);
+ *   const formatted = forge.format; // formatted value for display
+ *   const inputType = forge.htmlInputType; // e.g. 'text', 'area', 'email', etc.
+ *   const meta = forge.forge; // IDbForge metadata for the field
+ *
+ * This class is typically used via IDbCollections.getCollectionFieldForge for shared instance management.
  */
 export class IDbCollectionFieldForge {
     #collection;
@@ -605,9 +748,9 @@ export class IDbCollectionFieldForge {
     #fieldName;
     #data;
     #forge;
-    constructor(collection, fieldName, data) {
+    constructor(collection, fieldName, data, collectionValues) {
         this.#collection = collection;
-        this.#collectionValues = new IDbCollectionValues(collection);
+        this.#collectionValues = collectionValues ?? new IDbCollectionValues(collection);
         this.#fieldName = String(fieldName);
         this.#data = data;
     }
@@ -619,7 +762,7 @@ export class IDbCollectionFieldForge {
     }
     // renamed from parseCollectionFieldName
     get forge() {
-        return this.#collectionValues.dbCollections.parseCollectionFieldName(this.#collection, String(this.#fieldName));
+        return this.#collectionValues.idbCollections.parseCollectionFieldName(this.#collection, String(this.#fieldName));
     }
     get fieldArgs() {
         return this.forge?.fieldArgs;
@@ -663,14 +806,14 @@ class IDbValidationError extends Error {
 }
 export class IDbFormValidate {
     collection;
-    dbFields;
-    constructor(collection) {
+    idbCollections;
+    constructor(collection, idbCollections) {
         this.collection = collection;
-        this.dbFields = new IDbCollections();
+        this.idbCollections = idbCollections ?? new IDbCollections();
     }
     validateField(fieldName, value) {
         try {
-            const fieldInfo = this.dbFields.parseCollectionFieldName(this.collection, fieldName);
+            const fieldInfo = this.idbCollections.parseCollectionFieldName(this.collection, fieldName);
             if (!fieldInfo) {
                 return { isValid: false, error: `Field ${String(fieldName)} not found in collection` };
             }
@@ -735,7 +878,7 @@ export class IDbFormValidate {
         const errors = {};
         const invalidFields = [];
         let isValid = true;
-        const fields = this.dbFields.getCollectionTemplateFields(this.collection);
+        const fields = this.idbCollections.getCollectionTemplateFields(this.collection);
         if (!fields) {
             return {
                 isValid: false,

package/dist/form/CollectionFks.svelte

@@ -4,6 +4,7 @@
 	import type { TplCollectionName, Where } from '@medyll/idae-idbql';
 	import { Looper } from '@medyll/idae-slotui-svelte';
 
+	import { machine } from '../main/machine.js'; 
 	type CollectionFksProps = {
 		collection:    TplCollectionName;
 		collectionId?: any;
@@ -13,8 +14,9 @@
 
 	// idbqlState[fkCollection].get(fkId);
 
-	const dbFields = new IDbCollections(schemeModel);
-	const fks = $derived(dbFields.fks(collection));
+	const dbFields = machine.collections;
+	const collections = new IDbCollections(schemeModel);
+	const fks = $derived(collections.fks(collection));
 </script>
 
 <Looper data={Object.entries(fks)}>

package/dist/form/CollectionList.svelte

@@ -8,12 +8,13 @@
 		type Props,
 		Looper
 	} from '@medyll/idae-slotui-svelte';
-	import CreateUpdate from './CreateUpdate.svelte';
-	import { idbqlState } from '../db/dbSchema.js';
-	import { IDbCollections, IDbCollectionValues } from '../db/dbFields.js';
+	import CreateUpdate from './CreateUpdate.svelte'; 
 	import { hydrate, type Snippet } from 'svelte';
 	import type { Where } from '@medyll/idae-idbql';
 
+import {machine } from '../main/machine.js';
+
+
 	interface DataListProps {
 		collection:     string;
 		target?:        string; // html target
@@ -38,11 +39,12 @@
 		displayMode
 	}: DataListProps = $props();
 
-	let test = new IDbCollections();
-	let fieldValues = new IDbCollectionValues(collection);
-	let index = test.getIndexName(collection);
+	let collections = machine.collections;
+	let store = machine.store;
+	let fieldValues = machine.collections.get(collection).collectionValues() ;
+	let index = collections.get(collection).getIndexName();
 
-	let qy = $derived(where ? idbqlState[collection].where(where) : idbqlState[collection].getAll());
+	let qy = $derived(where ? store[collection].where(where) : store[collection].getAll());
 
 	function load(event: CustomEvent, indexV: number | string) {
 		openCrud(event[index]);

package/dist/form/CreateUpdate.svelte

@@ -4,11 +4,11 @@
  -->
 
 <script lang="ts" generics="COL = Record<string,any>">
-	import { IDbCollections as DbFields, IDbFormValidate } from '../db/dbFields';
-	import { idbql, idbqlState, schemeModel } from '../db/dbSchema';
+	import {  IDbFormValidate } from '../db/dbFields.js'; 
 	import type { CreateUpdateProps } from './types';
 	import CollectionReverseFks from './CollectionReverseFks.svelte';
 	import FieldInput from './FieldValue.svelte';
+ 	import {machine} from '../main/machine.js';
 
 	let {
 		collection,
@@ -22,16 +22,21 @@
 		afterCreate,
 		showFks = false
 	}: CreateUpdateProps = $props();
+	
+	
 	let inputForm = `form-${String(collection)}-${mode}`;
-	let dbFields = new DbFields(schemeModel);
-	let indexName = dbFields.getIndexName(collection);
+
+	let collections = machine.collections ;
+	let store = machine.store;
+	let indexName = collections.getIndexName(collection);
+
 	let formFields = showFields
 		? Object.fromEntries(
-				Object.entries(dbFields.parseRawCollection(collection) ?? {}).filter(([key]) => showFields.includes(key))
+				Object.entries(collections.parseRawCollection(collection) ?? {}).filter(([key]) => showFields.includes(key))
 			)
-		: (dbFields.parseRawCollection(collection) ?? {});
+		: (collections.parseRawCollection(collection) ?? {});
 
-	let qy: any = $derived(dataId && indexName ? idbqlState[collection].where({ [indexName]: { eq: dataId } }) : {});
+	let qy: any = $derived(dataId && indexName ? store[collection].where({ [indexName]: { eq: dataId } }) : {});
 
 	let formData = $state<Record<string, any>>({ ...data, ...withData, ...$state.snapshot(qy)[0] });
 
@@ -86,13 +91,13 @@
 		switch (mode) {
 			case 'create':
 				if (!dataId) {
-					await idbql[collection].add({ ...datadb, ...withData });
+					await store[collection].add({ ...datadb, ...withData });
 					mode = 'show';
 				}
 				break;
 			case 'update':
 				if (dataId) {
-					await idbqlState[collection].update(dataId, datadb);
+					await store[collection].update(dataId, datadb);
 				}
 				break;
 		}
@@ -141,7 +146,8 @@
 				{collection}
 				{fieldName}
 				{mode}
-				editInPlace={inPlaceEdit === true || (Array.isArray(inPlaceEdit) && inPlaceEdit.includes(fieldName))}
+				editInPlace={inPlaceEdit === true ||
+					(Array.isArray(inPlaceEdit) && inPlaceEdit.includes(fieldName))}
 				bind:data={formData}
 				{inputForm}
 			/>

package/dist/form/FieldValue.svelte

@@ -1,13 +1,11 @@
 <!-- Component: CollectionFieldValue.svelte (ancien nom CollectionFieldInput.svelte) -->
 <script lang="ts" generics="COL = Record<string,any>">
-	// Importation des types et composants nécessaires
-	import { IDbCollectionFieldForge, IDbCollectionValues } from '../db/dbFields.js';
-	import type { TplCollectionName } from '@medyll/idae-idbql';
-	import { IconButton } from '@medyll/idae-slotui-svelte';
-	import { getAllContexts, getContext } from 'svelte';
-
+	// Importation des types et composants nécessaires 
+	import type { TplCollectionName } from '@medyll/idae-idbql'; 
+	import {  getContext } from 'svelte';
+	import {machine} from '../main/machine.js';
 	interface FieldValueProps {
-		collection?:   TplCollectionName;
+		collection:   TplCollectionName;
 		collectionId?: any;
 		fieldName:     keyof COL;
 		data?:         COL;
@@ -36,11 +34,12 @@
 	data = data ?? ({} as COL);
 
 	// Initialisation des valeurs de champ de collection
-	let collectionFieldValues = new IDbCollectionValues(collection);
+	const forge = machine.collections.get(collection).fieldForge(String(fieldName), data)  
+	let collectionFieldValues = machine.collections.get(collection).collectionValues() 
 	let inputDataset = collectionFieldValues.getInputDataSet(fieldName, data);
 
 	// Création d'une instance de forge de champ de collection
-	const fieldForge = $derived(new IDbCollectionFieldForge(collection, fieldName, data));
+	const fieldForge = $derived(forge);
 
 	// Effet déclenché lorsque collectionId ou editInPlace change
 	$effect(() => {

package/dist/form/FieldValue.svelte.d.ts

@@ -1,7 +1,7 @@
 import type { TplCollectionName } from '@medyll/idae-idbql';
 declare function $$render<COL = Record<string, any>>(): {
     props: {
-        collection?: TplCollectionName;
+        collection: TplCollectionName;
         collectionId?: any;
         fieldName: keyof COL;
         data?: COL;

package/dist/main/machine.d.ts

@@ -1,3 +1,29 @@
+/**
+ * Example usage:
+ *
+ * import { Machine } from './machine.js';
+ *
+ * // Create a new Machine instance with default parameters
+ * const machine = new Machine( 'example-db', 1, { collections: {} });
+ *
+ * // Start the machine (initialize collections and IDBQL connection)
+ * machine.start();
+ *
+ * // Access collections (schema logic)
+ * const collections = machine.collections;
+ *
+ * // Access IDBQL (readonly)
+ * const idbql = machine.idbql;
+ *
+ * // Access IDBQL (stateful)
+ * const idbqlState = machine.idbqlState;
+ *
+ * // Access IndexedDB core
+ * const db = machine.indexedb;
+ *
+ * // Access the IDBQL data model
+ * const model = machine.idbqModel;
+ */
 import { IDbCollections } from '../db/dbFields.js';
 import { createIdbqDb, type IdbqModel } from '@medyll/idae-idbql';
 /**
@@ -12,7 +38,7 @@ export declare class Machine {
     /**
      * IDBQL (stateful collections instance)
      */
-    _idbqlState: ReturnType<ReturnType<typeof createIdbqDb>["create"]>["idbqlState"] | undefined;
+    _idbqlState: ReturnType<ReturnType<typeof createIdbqDb>["create"]>["idbqlState"];
     /**
      * Direct access to IndexedDB (core)
      */
@@ -24,7 +50,7 @@ export declare class Machine {
     /**
      * Centralized access to schema and collection logic
      */
-    _collections: IDbCollections | undefined;
+    _collections: IDbCollections;
     /**
      * Database name
      */
@@ -39,26 +65,23 @@ export declare class Machine {
     _model: IdbqModel;
     /**
      * 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?: IdbqModel);
-    /**
-     * Start the machine: initialize collections and IDBQL connection.
-     * @param options Optional overrides: { dbName, version, model }
      */
-    start(options?: {
+    constructor();
+    init(options?: {
         dbName?: string;
         version?: number;
         model?: IdbqModel;
     }): void;
+    /**
+     * Start the machine: initialize collections and IDBQL connection.
+     */
+    start(): void;
     private createCollections;
     private createStore;
     /**
      * Get the IDbCollections (schema logic) instance
      */
-    get collections(): IDbCollections | undefined;
+    get collections(): IDbCollections;
     /**
      * IDBQL (readonly) instance
      */
@@ -66,9 +89,10 @@ export declare class Machine {
     /**
      * IDBQL (stateful) instance
      */
-    get idbqlState(): import("@medyll/idae-idbql").StateCollections<IdbqModel<Record<string, Record<string, any>>>> | undefined;
+    get store(): import("@medyll/idae-idbql").StateCollections<IdbqModel<Record<string, Record<string, any>>>>;
     /**
      * IndexedDB (core) instance
+     * @deprecated
      */
     get indexedb(): import("@medyll/idae-idbql").IdbqlIndexedCore<IdbqModel<Record<string, Record<string, any>>>> | undefined;
     /**
@@ -76,3 +100,4 @@ export declare class Machine {
      */
     get idbqModel(): IdbqModel<Record<string, Record<string, any>>> | undefined;
 }
+export declare const machine: Machine;

package/dist/main/machine.js

@@ -24,7 +24,6 @@
  * // Access the IDBQL data model
  * const model = machine.idbqModel;
  */
-import { schemeModel } from '../db/dbSchema.js';
 import { IDbCollections } from '../db/dbFields.js';
 import { createIdbqDb } from '@medyll/idae-idbql';
 /**
@@ -66,23 +65,18 @@ export class Machine {
     _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;
+    constructor() {
     }
-    /**
-     * Start the machine: initialize collections and IDBQL connection.
-     * @param options Optional overrides: { dbName, version, model }
-     */
-    start(options) {
+    init(options) {
         this._dbName = options?.dbName ?? this._dbName;
         this._version = options?.version ?? this._version;
         this._model = options?.model ?? this._model;
+    }
+    /**
+     * Start the machine: initialize collections and IDBQL connection.
+     */
+    start() {
         this.createCollections();
         this.createStore();
     }
@@ -118,11 +112,12 @@ export class Machine {
     /**
      * IDBQL (stateful) instance
      */
-    get idbqlState() {
+    get store() {
         return this._idbqlState;
     }
     /**
      * IndexedDB (core) instance
+     * @deprecated
      */
     get indexedb() {
         return this._idbDatabase;
@@ -134,3 +129,4 @@ export class Machine {
         return this._idbqModel;
     }
 }
+export const machine = new Machine();

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@medyll/idae-machine",
-	"version": "0.111.0",
+	"version": "0.112.0",
 	"scripts": {
 		"dev": "vite dev",
 		"build": "vite build && npm run prepack",
@@ -59,5 +59,8 @@
 		"vite": "^6.2.3",
 		"vitest": "^3.0.9"
 	},
-	"scope": "@medyll"
-}
+	"scope": "@medyll",
+	"dependencies": {
+		"@huggingface/prettier-plugin-vertical-align": "^0.2.3"
+	}
+}