@medyll/idae-machine 0.87.0

package/README.md

@@ -0,0 +1,230 @@
+# @medyll/idae-machine
+
+**Low-code UI framework** for rapid data structure visualization and CRUD operations in Svelte 5. Declare your database schema once, automatically generate rich UI components for displaying, creating, and updating structured data in IndexedDB.
+
+## 🎯 Purpose
+
+`idae-machine` bridges the gap between **data modeling** (`@medyll/idae-idbql`) and **rich UI components** (`@medyll/idae-slotui-svelte`). It provides:
+- **Schema-driven UI generation**: Declare your data model, get form components for free
+- **CRUD Zone**: Pre-built "Create-Read-Update-Delete" interface for any collection
+- **Relational support**: Foreign key and reverse foreign key visualization
+- **In-place editing**: Edit records inline without modal dialogs
+- **Field-level validation**: Type-safe field rules (required, readonly, private)
+
+## 📦 Core Architecture
+
+### Layer Stack
+
+```
+UI Components (Svelte 5 Components)
+    ↓
+Form Management & Validation Logic
+    ↓
+Database Schema Definition (TypeScript Types)
+    ↓
+IndexedDB Abstraction (@medyll/idae-idbql)
+```
+
+### Key Modules
+
+| Module | Purpose |
+
+## 🚀 Quick Start
+import { createIdbqDb, type IdbqModel } from '@medyll/idae-idbql';
+
+    template: {
+      index: 'id',
+      presentation: 'name',
+      fields: {
+        id: 'id (readonly)',
+        name: 'text (required)',
+        code: 'text (required)',
+        model: 'text',
+        prompt: 'text-long',
+        created_at: 'date (private)',
+        ia_lock: 'boolean (private)'
+      },
+      fks: {
+        agentPrompt: {
+          code: 'agentPrompt',
+          multiple: true,
+          rules: 'readonly private'
+        }
+      }
+    }
+  }
+
+export const idbqlState = createIdbqDb(schemeModelDb);
+```
+
+### 2. Use CRUD Components
+
+```svelte
+<script lang="ts">
+  import { CrudZone, CreateUpdate, DataList } from '@medyll/idae-machine';
+</script>
+
+<!-- Full CRUD interface -->
+<CrudZone collection="agents" />
+
+<!-- Or compose individually -->
+<DataList collection="agents" />
+<CreateUpdate collection="agents" mode="create" />
+```
+
+## 📋 Component Guide
+
+### `<CrudZone>`
+Unified CRUD interface with sidebar list and detail editing.
+```svelte
+<CrudZone collection="agents" style="height: 600px; min-width: 750px" />
+```
+
+### `<DataList>`
+Displays collection records as grid with click-to-edit.
+```svelte
+<DataList 
+  collection="agents"
+  displayMode="grid"
+  where={{ active: { $eq: true } }}
+  onclick={(data, idx) => console.log(data)}
+/>
+```
+
+### `<CreateUpdate>`
+Form for creating/updating/viewing records.
+```svelte
+<CreateUpdate 
+  collection="agents"
+  mode="show"
+  dataId={1}
+  showFields={['name', 'code', 'model']}
+  inPlaceEdit={true}
+  showFks={true}
+/>
+```
+
+### `<FieldValue>`
+Renders a single field with intelligent type detection.
+```svelte
+<FieldValue 
+  collection="agents"
+  fieldName="name"
+  data={formData}
+  mode="edit"
+  editInPlace={true}
+/>
+```
+
+### Relational Components
+```svelte
+<!-- Foreign Keys (refs TO other collections) -->
+<CollectionFks collection="agents" />
+
+<!-- Reverse Foreign Keys (records pointing TO this one) -->
+<CollectionReverseFks collection="agents">
+  {#snippet children({ collection, template })}
+    <div>{collection} references this agent</div>
+  {/snippet}
+</CollectionReverseFks>
+```
+
+## 🔧 Schema Definition (dbFields.ts)
+
+Field types are declared using string-based DSL:
+
+```typescript
+fields: {
+  // Primitives
+  id: 'id (readonly)',
+  name: 'text (required)',
+  age: 'number',
+  active: 'boolean',
+  email: 'email',
+  created: 'date',
+  
+  // Text variants
+  bio: 'text-long',
+  note: 'text-area',
+  
+  // Relations
+  categoryId: 'fk-category.id (required)',
+  
+  // Collections
+  tagIds: 'array-of-number',
+  
+  // Modifiers
+  password: 'password (private)',
+  system_field: 'text (readonly private)'
+}
+```
+
+## 📝 Development Status
+
+⚠️ **Early Development Phase**
+
+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
+
+### Current Focus Areas
+- ✅ Schema declaration & type safety
+- ✅ Database integration with idae-idbql
+- ✅ Component exports & library structure
+- 🔄 Form validation (in progress)
+- 🔄 Field rendering pipeline (needs refinement)
+- ⏳ End-to-end CRUD workflows
+- ⏳ Comprehensive test coverage
+
+## 🔗 Dependencies
+
+- **@medyll/idae-idbql**: IndexedDB abstraction with schema support
+- **@medyll/idae-slotui-svelte**: UI component library (Button, MenuList, Looper, etc.)
+- **svelte**: ^5.0.0 (uses Svelte 5 runes)
+### Build
+```bash
+### Development Server
+```bash
+npm run dev          # Start dev server on localhost
+npm run dev -- --open  # Auto-open in browser
+```
+
+### Quality Assurance
+```bash
+npm run check        # Svelte type checking
+npm run lint         # ESLint + Prettier check
+npm run format       # Auto-format code
+npm run test:unit    # Run Vitest unit tests
+npm run test         # Single-run test mode
+```
+
+## 📚 Code Structure
+
+```
+src/lib/
+├── db/                    # Schema & field layers
+│   ├── dbSchema.ts       # Collection templates
+│   ├── dbFields.ts       # Field rules & validation
+│   └── dataModel.ts      # TypeScript types
+│   ├── CollectionFks.svelte      # Forward relations
+│   ├── CollectionReverseFks.svelte # Back-references
+│   └── ...
+└── index.ts             # Main exports
+```
+
+## 🎓 Example Projects
+
+See `src/routes/` for a working showcase of all components in action.
+
+## 📄 License
+
+MIT - See LICENSE file
+
+---
+
+**Next Steps for Contributors:**
+1. Stabilize form validation pipeline
+2. Add comprehensive test suite
+3. Document TypeScript schema inference
+4. Create migration guides from legacy code in `src/_old/`

package/dist/db/dataModel.d.ts

@@ -0,0 +1,23 @@
+export type DbDataModel<T = Record<string, CollectionDbModel>> = {
+    readonly [K in keyof T]: CollectionDbModel<T[K]>;
+};
+export interface CollectionDbModel<T = Record<string, any>> {
+    keyPath: string | any;
+    ts: any;
+    model: any;
+    template?: {
+        index: string;
+        presentation: any;
+        fields?: {};
+        fks?: {
+            code: string;
+            multiple: boolean;
+            rules: string;
+        };
+    };
+}
+export type DbDataModelTs<T extends Record<string, {
+    ts: any;
+}> = DbDataModel> = {
+    [K in keyof T]: T[K]['ts'];
+};

package/dist/db/dataModel.js

@@ -0,0 +1,40 @@
+const monModel = {
+    agent: {
+        keyPath: '++id, promptId, created_at',
+        ts: {},
+        model: {},
+        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)'
+            }
+        }
+    },
+    agentPrompt: {
+        keyPath: '++id, created_at',
+        ts: {},
+        model: {},
+        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)'
+            }
+        }
+    }
+};
+export {};
+//

package/dist/db/dbFields.d.ts

@@ -0,0 +1,130 @@
+import type { CollectionModel, IdbqModel, TplCollectionName, Tpl, TplFields } from '@medyll/idae-idbql';
+export declare enum enumPrimitive {
+    id = "id",
+    any = "any",
+    date = "date",
+    datetime = "datetime",
+    time = "time",
+    text = "text",
+    number = "number",
+    boolean = "boolean",
+    url = "url",
+    email = "email",
+    phone = "phone",
+    password = "password"
+}
+export declare enum TplProperties {
+    'private' = "private",
+    'readonly' = "readonly",
+    'required' = "required"
+}
+type CombineElements<T extends string, U extends string = T> = T extends any ? T | `${T} ${CombineElements<Exclude<U, T>>}` : never;
+type CombinedArgs = CombineElements<TplProperties>;
+type IdbObjectify<T extends string = 'number'> = `array-of-${T}` | `object-${T}`;
+export type IdDbPrimitive<T = {}> = keyof typeof enumPrimitive | `text-${'tiny' | 'short' | 'medium' | 'long' | 'area'}` | `${string}.${string}` | `fk-${string}.${string}`;
+export type IDbObjectPrimitive = IdbObjectify<IdDbPrimitive>;
+export type IDbFk = `fk-${string}.${string}`;
+export type IDbFkObject = IdbObjectify<IDbFk>;
+export type IDbTypes = IdDbPrimitive | IDbObjectPrimitive | IDbFk | IDbFkObject;
+export type IDBArgumentsTypes = `${IDbTypes}(${CombinedArgs})`;
+export type IDbFieldRules = IDBArgumentsTypes | IDbTypes;
+export type IDbFieldType = IDBArgumentsTypes | IDbTypes;
+type IDbForgeArgs = keyof typeof TplProperties;
+export type IDbForge = {
+    collection?: TplCollectionName;
+    fieldName?: keyof TplFields;
+    fieldType?: IDbFieldType;
+    fieldRule?: IDbFieldRules;
+    fieldArgs?: IDbForgeArgs | undefined;
+    is: any;
+};
+export declare class IDbCollections {
+    #private;
+    model: IdbqModel;
+    constructor(model?: IdbqModel);
+    parseAllCollections(): Record<string, Record<string, IDbForge | undefined> | undefined>;
+    parseRawCollection(collection: TplCollectionName): Record<string, IDbForge | undefined> | undefined;
+    parseCollectionFieldName(collection: TplCollectionName, fieldName: keyof TplFields): IDbForge | undefined;
+    parsFieldRule(fieldRule: IDbFieldRules): Partial<IDbForge> | undefined;
+    private forge;
+    getCollection(collection: TplCollectionName): CollectionModel;
+    getCollectionTemplate(collection: TplCollectionName): Tpl;
+    getCollectionTemplateFks(collection: TplCollectionName): Tpl["fks"];
+    getIndexName(collection: string): string;
+    getCollectionTemplateFields(collection: TplCollectionName): TplFields;
+    getTemplatePresentation(collection: TplCollectionName): string;
+    getFkFieldType(string: `${string}.${string}`): IDbFieldRules | undefined;
+    getFkTemplateFields(string: `${string}.${string}`): {
+        [x: string]: import("@medyll/idae-idbql").TplFieldRules;
+    };
+    private testIs;
+    is(what: 'array' | 'object' | 'fk' | 'primitive', fieldRule: IDbFieldRules): Partial<IDbForge>;
+    indexValue(collection: TplCollectionName, data: Record<string, any>): any;
+    extract(type: 'array' | 'object' | 'fk' | 'primitive', fieldRule: IDbFieldRules): Partial<IDbForge>;
+    fks(collection: string): {
+        [collection: string]: Tpl;
+    };
+    reverseFks(targetCollection: TplCollectionName): Record<string, any>;
+    iterateArrayField(collection: TplCollectionName, fieldName: keyof TplFields, data: any[]): IDbForge[];
+    iterateObjectField(collection: TplCollectionName, fieldName: keyof TplFields, data: Record<string, any>): IDbForge[];
+}
+export declare class IDbCollectionValues<T extends Record<string, any>> {
+    #private;
+    dbCollections: IDbCollections;
+    private collection;
+    constructor(collection: TplCollectionName);
+    presentation(data: Record<string, any>): string;
+    indexValue(data: Record<string, any>): any | null;
+    format(fieldName: keyof T, data: T): string;
+    getInputDataSet(fieldName: string, data: T): Record<`data-${'collection' | 'collectionId' | 'fieldName' | 'fieldType' | 'fieldArgs'}`, string>;
+    iterateArrayField(fieldName: keyof TplFields, data: any[]): IDbForge[];
+    iterateObjectField(fieldName: keyof TplFields, data: Record<string, any>): IDbForge[];
+}
+export declare class IDbCollectionFieldValues<T extends Record<string, any>> {
+    #private;
+    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[];
+}
+export declare class IDbCollectionFieldForge<T extends Record<string, any>> {
+    #private;
+    constructor(collection: TplCollectionName, fieldName: any, data: T);
+    get format(): string;
+    get inputDataSet(): Record<"data-collection" | "data-fieldName" | "data-fieldType" | "data-fieldArgs" | "data-collectionId", string>;
+    get forge(): IDbForge | undefined;
+    get fieldArgs(): IDbForgeArgs | undefined;
+    get fieldType(): IDbFieldType | undefined;
+    /**
+     * will return  text.inputBase  for ['url', 'email', 'number', 'date', 'time', 'datetime', 'phone', 'password']
+     */
+    get htmlInputType(): string | 'text' | 'area';
+    get rawData(): T;
+    iterateArray(fieldName: string, data: any[]): IDbForge[];
+    iterateObject(fieldName: string, data: Record<string, any>): IDbForge[];
+}
+export declare class IDbFormValidate {
+    #private;
+    private collection;
+    private dbFields;
+    constructor(collection: TplCollectionName);
+    validateField(fieldName: keyof TplFields, value: any): {
+        isValid: boolean;
+        error?: string;
+    };
+    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;
+}
+export {};