@medyll/idae-machine 0.124.0 → 0.125.0

package/dist/main/machine/IDbCollectionValues.js

@@ -0,0 +1,203 @@
+import { MachineDb } from '../machineDb.js';
+import {} from '../machineForge.js';
+import { IDbError } from './IDbError.js';
+/**
+ * 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 (IDbBase).
+ * - 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 IDbBase.getCollectionValues for shared instance management.
+ * @template T - The type of the data object for the collection.
+ */
+export class IDbCollectionValues {
+    /**
+     * The IDbBase instance used for schema introspection.
+     */
+    idbBase;
+    /**
+     * The collection name this instance operates on.
+     */
+    collectionName;
+    /**
+     * Create a new IDbCollectionValues instance for a given collection.
+     * @param collectionName The collection name.
+     */
+    constructor(collectionName, idbBase) {
+        this.collectionName = collectionName;
+        this.idbBase = idbBase ?? new MachineDb();
+    }
+    presentation(data) {
+        try {
+            this.#checkError(!this.#checkAccess(), 'Access denied', 'ACCESS_DENIED');
+            const presentation = this.idbBase.collection(this.collectionName).getPresentation();
+            this.#checkError(!presentation, 'Presentation template not found', 'TEMPLATE_NOT_FOUND');
+            const fields = presentation.split(' ');
+            return fields
+                .map((field) => {
+                const value = data[field];
+                return value !== null && value !== undefined ? String(value) : '';
+            })
+                .join(' ');
+        }
+        catch (error) {
+            IDbError.handleError(error);
+            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');
+            const indexName = this.idbBase.collection(this.collectionName).getIndexName();
+            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];
+        }
+        catch (error) {
+            IDbError.handleError(error);
+            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');
+            this.#checkError(!(fieldName in data), `Field ${String(fieldName)} not found in data`, 'FIELD_NOT_FOUND');
+            const fieldInfo = this.idbBase.parseCollectionFieldName(this.collectionName, fieldName);
+            this.#checkError(!fieldInfo, `Field ${String(fieldName)} not found in collection`, 'FIELD_NOT_FOUND');
+            switch (fieldInfo?.fieldType) {
+                case 'number':
+                    return this.#formatNumberField(data[fieldName]);
+                case 'text':
+                case 'text-tiny':
+                case 'text-short':
+                case 'text-medium':
+                case 'text-long':
+                case 'text-giant':
+                    return this.#formatTextField(data[fieldName], fieldInfo.fieldType);
+                default:
+                    return String(data[fieldName]);
+            }
+        }
+        catch (error) {
+            IDbError.handleError(error);
+            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.idbBase.parseCollectionFieldName(this.collectionName, fieldName);
+        const fieldType = fieldInfo?.fieldType ?? '';
+        const fieldArgs = fieldInfo?.fieldArgs?.join(' ') ?? '';
+        const indexName = this.idbBase.collection(this.collectionName).getIndexName();
+        return {
+            'data-collection': this.collectionName,
+            'data-collectionId': indexName && data?.[indexName] !== undefined ? String(data?.[indexName]) : '',
+            'data-fieldName': String(fieldName),
+            'data-fieldType': fieldType,
+            '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) {
+        const fieldInfo = this.idbBase.parseCollectionFieldName(this.collectionName, fieldName);
+        if (fieldInfo?.is !== 'array' || !Array.isArray(data)) {
+            return [];
+        }
+        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 fieldName The field name.
+     * @param data The object data.
+     * @returns An array of IDbForge objects.
+     */
+    iterateObjectField(fieldName, data) {
+        const fieldInfo = this.idbBase.parseCollectionFieldName(this.collectionName, fieldName);
+        if (fieldInfo?.is !== 'object' || typeof data !== 'object' || data === null) {
+            return [];
+        }
+        return Object.keys(data).map((key) => ({ ...fieldInfo, fieldName: `${String(fieldName)}.${key}` }));
+    }
+    /**
+     * 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,
+            'text-short': 20,
+            'text-medium': 30,
+            'text-long': 40,
+            'text-giant': 50
+        };
+        const str = typeof value === 'string' ? value : String(value ?? '');
+        const maxLength = lengths[type] || str.length;
+        return str.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);
+        }
+    }
+}

package/dist/main/machine/IDbError.d.ts

@@ -0,0 +1,6 @@
+export declare class IDbError extends Error {
+    readonly code: string;
+    constructor(message: string, code: string);
+    static throwError(message: string, code: string): void;
+    static handleError(error: unknown): void;
+}

package/dist/main/machine/IDbError.js

@@ -0,0 +1,61 @@
+/*
+    renamed from DbCollectionError to IDbErrors
+ */
+export class IDbError extends Error {
+    code;
+    constructor(message, code) {
+        super(message);
+        this.code = code;
+        this.name = 'DbCollectionError';
+    }
+    static throwError(message, code) {
+        throw new IDbError(message, code);
+    }
+    static handleError(error) {
+        if (error instanceof IDbError) {
+            console.error(`${error.name}: ${error.message} (Code: ${error.code})`);
+            /**
+             * IDbError
+             *
+             * Custom error class for collection-related errors.
+             *
+             * Usage:
+             *   throw new IDbError('Message', 'ERROR_CODE');
+             *   IDbError.handleError(error);
+             */
+            export class IDbError extends Error {
+                code;
+                /**
+                 * Create a new IDbError instance.
+                 * @param message The error message.
+                 * @param code The error code.
+                 */
+                constructor(message, code) {
+                    super(message);
+                    this.code = code;
+                    this.name = 'DbCollectionError';
+                }
+                /**
+                 * Throw a new IDbError.
+                 * @param message The error message.
+                 * @param code The error code.
+                 */
+                static throwError(message, code) {
+                    throw new IDbError(message, code);
+                }
+                /**
+                 * Handle an error, logging details if it's an IDbError.
+                 * @param error The error to handle.
+                 */
+                static handleError(error) {
+                    if (error instanceof IDbError) {
+                        console.error(`${error.name}: ${error.message} (Code: ${error.code})`);
+                    }
+                    else {
+                        console.error('Unexpected error:', error);
+                    }
+                }
+            }
+        }
+    }
+}

package/dist/main/machine/IDbFormValidate.d.ts

@@ -0,0 +1,55 @@
+import type { TplCollectionName, TplFields } from '@medyll/idae-idbql';
+import { MachineDb } from '../machineDb.js';
+/**
+ * IDbFormValidate
+ *
+ * Provides validation utilities for form fields in a collection.
+ *
+ * Main responsibilities:
+ * - Holds a reference to the collection and schema.
+ * - Validates field values according to type and arguments.
+ * - Supports custom validation for email, URL, phone, and date/time fields.
+ *
+ * Usage:
+ *   const validator = new IDbFormValidate('agents');
+ *   const result = validator.validateField('email', value);
+ */
+export declare class IDbFormValidate {
+    #private;
+    private collection;
+    private idbCollections;
+    /**
+     * Create a new IDbFormValidate instance.
+     * @param collection The collection name.
+     * @param idbCollections Optional MachineDb instance.
+     */
+    constructor(collection: TplCollectionName, idbCollections?: MachineDb);
+    /**
+     * Validate a field value for the collection.
+     * @param fieldName The field name.
+     * @param value The value to validate.
+     * @returns An object with isValid and optional error.
+     */
+    validateField(fieldName: keyof TplFields, value: any): {
+        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;
+    }): {
+        isValid: boolean;
+        errors: Record<string, string>;
+        invalidFields: string[];
+    };
+    private validateEmail;
+    private validateUrl;
+    private validatePhone;
+    private validateDateTime;
+}

package/dist/main/machine/IDbFormValidate.js

@@ -0,0 +1,183 @@
+import { MachineDb, enumPrimitive } from '../machineDb.js';
+import { IDbValidationError } from './IDbValidationError.js';
+/**
+ * IDbFormValidate
+ *
+ * Provides validation utilities for form fields in a collection.
+ *
+ * Main responsibilities:
+ * - Holds a reference to the collection and schema.
+ * - Validates field values according to type and arguments.
+ * - Supports custom validation for email, URL, phone, and date/time fields.
+ *
+ * Usage:
+ *   const validator = new IDbFormValidate('agents');
+ *   const result = validator.validateField('email', value);
+ */
+export class IDbFormValidate {
+    collection;
+    idbCollections;
+    /**
+     * Create a new IDbFormValidate instance.
+     * @param collection The collection name.
+     * @param idbCollections Optional MachineDb instance.
+     */
+    constructor(collection, idbCollections) {
+        this.collection = collection;
+        this.idbCollections = idbCollections ?? new MachineDb();
+    }
+    /**
+     * Validate a field value for the collection.
+     * @param fieldName The field name.
+     * @param value The value to validate.
+     * @returns An object with isValid and optional error.
+     */
+    validateField(fieldName, value) {
+        try {
+            const fieldInfo = this.idbCollections.parseCollectionFieldName(this.collection, fieldName);
+            if (!fieldInfo) {
+                return { isValid: false, error: `Field ${String(fieldName)} not found in collection` };
+            }
+            // Type checking
+            if (!this.#validateType(value, fieldInfo.fieldType)) {
+                return this.#returnError(fieldName, fieldInfo.fieldType);
+            }
+            // Check field arguments (required, etc.)
+            if (fieldInfo.fieldArgs) {
+                for (const arg of fieldInfo.fieldArgs) {
+                    if (arg === 'required' && (value === undefined || value === null || value === '')) {
+                        return this.#returnError(fieldName, 'required');
+                    }
+                }
+            }
+            // Specific validations according to field type
+            switch (fieldInfo.fieldType) {
+                case enumPrimitive.email:
+                    if (!this.validateEmail(value)) {
+                        return this.#returnError(fieldName, fieldInfo.fieldType);
+                    }
+                    break;
+                case enumPrimitive.url:
+                    if (!this.validateUrl(value)) {
+                        return this.#returnError(fieldName, fieldInfo.fieldType);
+                    }
+                    break;
+                case enumPrimitive.phone:
+                    if (!this.validatePhone(value)) {
+                        return this.#returnError(fieldName, fieldInfo.fieldType);
+                    }
+                    break;
+                case enumPrimitive.date:
+                case enumPrimitive.datetime:
+                case enumPrimitive.time:
+                    if (!this.validateDateTime(value, fieldInfo.fieldType)) {
+                        return this.#returnError(fieldName, fieldInfo.fieldType);
+                    }
+                    break;
+                // Add other specific cases here
+            }
+            return { isValid: true };
+        }
+        catch (error) {
+            if (error instanceof IDbValidationError) {
+                return { isValid: false, error: error.message };
+            }
+            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) {
+        const result = this.validateField(fieldName, value);
+        return !!result.isValid;
+    }
+    validateForm(formData, options = {}) {
+        const errors = {};
+        const invalidFields = [];
+        let isValid = true;
+        const fields = this.idbCollections.collection(this.collection).getTemplate().fields;
+        if (!fields) {
+            return {
+                isValid: false,
+                errors: { general: 'Collection template not found' },
+                invalidFields: ['general']
+            };
+        }
+        for (const [fieldName, fieldRule] of Object.entries(fields)) {
+            // Ignorer les champs spécifiés dans options.ignoreFields
+            if (options.ignoreFields && options.ignoreFields.includes(fieldName)) {
+                continue;
+            }
+            const result = this.validateField(fieldName, formData[fieldName]);
+            if (!result.isValid) {
+                errors[fieldName] = result.error || 'Invalid field';
+                invalidFields.push(fieldName);
+                isValid = false;
+            }
+        }
+        return { isValid, errors, invalidFields };
+    }
+    #validateType(value, type) {
+        switch (type) {
+            case enumPrimitive.number:
+                return typeof value === 'number' && !isNaN(value);
+            case enumPrimitive.boolean:
+                return typeof value === 'boolean';
+            case enumPrimitive.text:
+            case enumPrimitive.email:
+            case enumPrimitive.url:
+            case enumPrimitive.phone:
+            case enumPrimitive.password:
+                return typeof value === 'string';
+            case enumPrimitive.date:
+            case enumPrimitive.datetime:
+            case enumPrimitive.time:
+                return value instanceof Date || typeof value === 'string';
+            case enumPrimitive.any:
+                return true;
+            default:
+                return true; // Pour les types non gérés, on considère que c'est valide
+        }
+    }
+    #returnError(fieldName, enumCode) {
+        throw new IDbValidationError(String(fieldName), enumCode ?? 'unknown', `Invalid format for field ${String(fieldName)}. Cause "${enumCode}" `);
+    }
+    validateEmail(email) {
+        const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+        return emailRegex.test(email);
+    }
+    validateUrl(url) {
+        try {
+            new URL(url);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    validatePhone(phone) {
+        // Ceci est un exemple simple. Vous pouvez ajuster selon vos besoins spécifiques
+        const phoneRegex = /^\+?[\d\s-]{10,}$/;
+        return phoneRegex.test(phone);
+    }
+    validateDateTime(value, type) {
+        const date = value instanceof Date ? value : new Date(value);
+        if (isNaN(date.getTime()))
+            return false;
+        switch (type) {
+            case enumPrimitive.date:
+                return true; // La conversion en Date a déjà validé le format
+            case enumPrimitive.time:
+                // Vérifiez si la chaîne contient uniquement l'heure
+                return /^([01]\d|2[0-3]):([0-5]\d)(:([0-5]\d))?$/.test(value);
+            case enumPrimitive.datetime:
+                return true; // La conversion en Date a déjà validé le format
+            default:
+                return false;
+        }
+    }
+}

package/dist/main/machine/IDbValidationError.d.ts

@@ -0,0 +1,19 @@
+/**
+ * IDbValidationError
+ *
+ * Custom error class for validation errors on form fields.
+ *
+ * Usage:
+ *   throw new IDbValidationError('email', 'INVALID_EMAIL', 'Invalid email address');
+ */
+export declare class IDbValidationError extends Error {
+    field: string;
+    code: string;
+    /**
+     * Create a new IDbValidationError instance.
+     * @param field The field name.
+     * @param code The error code.
+     * @param message The error message.
+     */
+    constructor(field: string, code: string, message: string);
+}

package/dist/main/machine/IDbValidationError.js

@@ -0,0 +1,24 @@
+/**
+ * IDbValidationError
+ *
+ * Custom error class for validation errors on form fields.
+ *
+ * Usage:
+ *   throw new IDbValidationError('email', 'INVALID_EMAIL', 'Invalid email address');
+ */
+export class IDbValidationError extends Error {
+    field;
+    code;
+    /**
+     * Create a new IDbValidationError instance.
+     * @param field The field name.
+     * @param code The error code.
+     * @param message The error message.
+     */
+    constructor(field, code, message) {
+        super(message);
+        this.field = field;
+        this.code = code;
+        this.name = 'IDbValidationError';
+    }
+}