@almadar/runtime 4.10.2 → 4.11.0

package/dist/{chunk-K36736GF.js → chunk-RCWMQH7Y.js}

@@ -1,6 +1,7 @@
 import { resolveBinding, evaluate, createMinimalContext, evaluateGuard } from '@almadar/evaluator';
 export { createMinimalContext } from '@almadar/evaluator';
 import { isKnownOperator } from '@almadar/std';
+import { faker } from '@faker-js/faker';
 import { OrbitalSchemaSchema, isEntityCall, isEntityReference, parseEntityRef, parseImportedTraitRef, isPageReference, isPageReferenceString, isPageReferenceObject, parsePageRef } from '@almadar/core';
 
 // src/EventBus.ts
@@ -1476,6 +1477,286 @@ function createTestExecutor(overrides = {}) {
     debug: true
   });
 }
+var MockPersistenceAdapter = class {
+  stores = /* @__PURE__ */ new Map();
+  schemas = /* @__PURE__ */ new Map();
+  idCounters = /* @__PURE__ */ new Map();
+  config;
+  constructor(config = {}) {
+    this.config = {
+      defaultSeedCount: 6,
+      debug: false,
+      ...config
+    };
+    if (config.seed !== void 0) {
+      faker.seed(config.seed);
+      if (this.config.debug) {
+        console.log(`[MockPersistence] Using seed: ${config.seed}`);
+      }
+    }
+  }
+  // ============================================================================
+  // Store Management
+  // ============================================================================
+  getStore(entityName) {
+    const normalized = entityName.toLowerCase();
+    if (!this.stores.has(normalized)) {
+      this.stores.set(normalized, /* @__PURE__ */ new Map());
+      this.idCounters.set(normalized, 0);
+    }
+    return this.stores.get(normalized);
+  }
+  nextId(entityName) {
+    const normalized = entityName.toLowerCase();
+    const counter = (this.idCounters.get(normalized) ?? 0) + 1;
+    this.idCounters.set(normalized, counter);
+    return `${this.capitalizeFirst(entityName)} Id ${counter}`;
+  }
+  // ============================================================================
+  // Schema & Seeding
+  // ============================================================================
+  /**
+   * Register an entity schema and seed mock data.
+   * If the schema has seedData, those instances are used directly.
+   * Otherwise, random mock data is generated with faker.
+   */
+  registerEntity(schema, seedCount) {
+    const normalized = schema.name.toLowerCase();
+    this.schemas.set(normalized, schema);
+    if (schema.seedData && schema.seedData.length > 0) {
+      this.seedFromInstances(schema.name, schema.seedData);
+    } else {
+      const count = seedCount ?? this.config.defaultSeedCount ?? 6;
+      this.seed(schema.name, schema.fields, count);
+    }
+  }
+  /**
+   * Seed an entity with pre-authored instance data.
+   */
+  seedFromInstances(entityName, instances) {
+    const store = this.getStore(entityName);
+    if (this.config.debug) {
+      console.log(`[MockPersistence] Seeding ${instances.length} ${entityName} from schema instances...`);
+    }
+    for (const instance of instances) {
+      const id = instance.id || this.nextId(entityName);
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      const item = {
+        ...instance,
+        id,
+        createdAt: instance.createdAt || now,
+        updatedAt: now
+      };
+      store.set(id, item);
+    }
+  }
+  /**
+   * Seed an entity with mock data.
+   */
+  seed(entityName, fields, count) {
+    const store = this.getStore(entityName);
+    const normalized = entityName.toLowerCase();
+    if (this.config.debug) {
+      console.log(`[MockPersistence] Seeding ${count} ${entityName}...`);
+    }
+    for (let i = 0; i < count; i++) {
+      const item = this.generateMockItem(normalized, entityName, fields, i + 1);
+      store.set(item.id, item);
+    }
+  }
+  /**
+   * Generate a single mock item based on field schemas.
+   */
+  generateMockItem(normalizedName, entityName, fields, index) {
+    const id = this.nextId(entityName);
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const item = {
+      id,
+      createdAt: faker.date.past({ years: 1 }).toISOString(),
+      updatedAt: now
+    };
+    for (const field of fields) {
+      if (field.name === "id" || field.name === "createdAt" || field.name === "updatedAt") {
+        continue;
+      }
+      item[field.name] = this.generateFieldValue(entityName, field, index);
+    }
+    return item;
+  }
+  /**
+   * Generate a mock value for a field based on its schema.
+   */
+  generateFieldValue(entityName, field, index) {
+    if (field.default !== void 0) {
+      if (field.default === "@now") {
+        return (/* @__PURE__ */ new Date()).toISOString();
+      }
+      return field.default;
+    }
+    const fieldType = field.type.toLowerCase();
+    switch (fieldType) {
+      case "string":
+        return this.generateStringValue(entityName, field, index);
+      case "number":
+        return faker.number.int({ min: 0, max: 100 });
+      case "boolean":
+        return faker.datatype.boolean();
+      case "date":
+      case "timestamp":
+      case "datetime":
+        return this.generateDateValue(field);
+      case "enum":
+        if (field.values && field.values.length > 0) {
+          return faker.helpers.arrayElement(field.values);
+        }
+        return null;
+      case "relation":
+        return null;
+      // Relations need special handling
+      case "array":
+        return [];
+      case "object":
+        return null;
+      default:
+        return this.generateStringValue(entityName, field, index);
+    }
+  }
+  /**
+   * Generate a string value based on the field's declared schema metadata.
+   * Reads `values` (enum) first, then `format` (email/url/phone/uuid/date/
+   * datetime), then falls back to faker.lorem.words. No field-name heuristics
+   * — the schema is the source of truth. If a caller needs a real email, they
+   * declare `format: "email"`; if they need an enum, they declare `values: [...]`.
+   */
+  generateStringValue(_entityName, field, _index) {
+    if (field.values && field.values.length > 0) {
+      return faker.helpers.arrayElement(field.values);
+    }
+    switch (field.format) {
+      case "email":
+        return faker.internet.email();
+      case "url":
+        return faker.internet.url();
+      case "phone":
+        return faker.phone.number();
+      case "uuid":
+        return faker.string.uuid();
+      case "date":
+        return faker.date.recent().toISOString().split("T")[0];
+      case "datetime":
+        return faker.date.recent().toISOString();
+      default:
+        return faker.lorem.words(2);
+    }
+  }
+  /**
+   * Generate a date value. Uses the field's `format` (date vs datetime) to
+   * decide ISO shape; otherwise returns a recent ISO-8601 datetime. No
+   * field-name heuristics.
+   */
+  generateDateValue(field) {
+    const date = faker.date.recent({ days: 30 });
+    if (field.format === "date") return date.toISOString().split("T")[0];
+    return date.toISOString();
+  }
+  capitalizeFirst(str) {
+    return str.charAt(0).toUpperCase() + str.slice(1);
+  }
+  // ============================================================================
+  // PersistenceAdapter Implementation
+  // ============================================================================
+  async create(entityType, data) {
+    const store = this.getStore(entityType);
+    const id = this.nextId(entityType);
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const withDefaults = this.applyFieldDefaults(entityType, data);
+    const item = {
+      ...withDefaults,
+      id,
+      createdAt: now,
+      updatedAt: now
+    };
+    store.set(id, item);
+    return { id };
+  }
+  /**
+   * Fill in any entity-declared field defaults that the caller omitted.
+   * SAVE payloads coming from form-section only carry the fields the user
+   * edited; persisted rows should still honor `field.default` so downstream
+   * row-content probes (VG11f) see a row whose every declared-default field
+   * is non-empty. `@now` resolves to the current ISO timestamp.
+   */
+  applyFieldDefaults(entityType, data) {
+    const schema = this.schemas.get(entityType.toLowerCase());
+    if (!schema) return data;
+    const result = { ...data };
+    for (const field of schema.fields) {
+      if (field.name === "id" || field.name === "createdAt" || field.name === "updatedAt") continue;
+      if (result[field.name] !== void 0) continue;
+      if (field.default === void 0) continue;
+      result[field.name] = field.default === "@now" ? (/* @__PURE__ */ new Date()).toISOString() : field.default;
+    }
+    return result;
+  }
+  async update(entityType, id, data) {
+    const store = this.getStore(entityType);
+    const existing = store.get(id);
+    if (!existing) {
+      throw new Error(`Entity ${entityType} with id ${id} not found`);
+    }
+    const updated = {
+      ...existing,
+      ...data,
+      id,
+      // Preserve original ID
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    store.set(id, updated);
+  }
+  async delete(entityType, id) {
+    const store = this.getStore(entityType);
+    if (!store.has(id)) {
+      throw new Error(`Entity ${entityType} with id ${id} not found`);
+    }
+    store.delete(id);
+  }
+  async getById(entityType, id) {
+    const store = this.getStore(entityType);
+    return store.get(id) ?? null;
+  }
+  async list(entityType) {
+    const store = this.getStore(entityType);
+    return Array.from(store.values());
+  }
+  // ============================================================================
+  // Utilities
+  // ============================================================================
+  /**
+   * Clear all data for an entity.
+   */
+  clear(entityName) {
+    const normalized = entityName.toLowerCase();
+    this.stores.delete(normalized);
+    this.idCounters.delete(normalized);
+  }
+  /**
+   * Clear all data.
+   */
+  clearAll() {
+    this.stores.clear();
+    this.idCounters.clear();
+  }
+  /**
+   * Get count of items for an entity.
+   */
+  count(entityName) {
+    const store = this.getStore(entityName);
+    return store.size;
+  }
+};
+function createMockPersistence(config) {
+  return new MockPersistenceAdapter(config);
+}
 
 // src/loader/schema-loader.ts
 function isElectron() {
@@ -2843,6 +3124,70 @@ function parseNamespacedEvent(eventName) {
   return { event: eventName };
 }
 
-export { EffectExecutor, EventBus, HANDLER_MANIFEST, StateMachineManager, containsBindings, createContextFromBindings, createInitialTraitState, createTestExecutor, createUnifiedLoader, extractBindings, findInitialState, findTransition, getIsolatedCollectionName, getNamespacedEvent, interpolateProps, interpolateValue, isBrowser, isElectron, isNamespacedEvent, isNode, normalizeEventKey, parseNamespacedEvent, preprocessSchema, processEvent };
-//# sourceMappingURL=chunk-K36736GF.js.map
-//# sourceMappingURL=chunk-K36736GF.js.map
+// src/PersistenceAdapter.ts
+var InMemoryPersistence = class {
+  data = /* @__PURE__ */ new Map();
+  idCounter = 0;
+  /**
+   * Seed the store with pre-existing rows.
+   *
+   * Accepts either a plain `Record<entityType, EntityRow[]>` or an iterable
+   * of `[entityType, EntityRow[]]` entries. Rows without an `id` get one
+   * generated at insert time; rows with an `id` keep it (so re-seeding
+   * after a schema rebuild preserves identities used in render bindings).
+   */
+  seed(seedData) {
+    const entries = Symbol.iterator in Object(seedData) ? seedData : Object.entries(seedData);
+    for (const [entityType, rows] of entries) {
+      if (!this.data.has(entityType)) {
+        this.data.set(entityType, /* @__PURE__ */ new Map());
+      }
+      const collection = this.data.get(entityType);
+      for (const row of rows) {
+        const id = row.id || `${entityType}-${++this.idCounter}`;
+        collection.set(id, { ...row, id });
+      }
+    }
+  }
+  async create(entityType, data) {
+    const id = data.id || `${entityType}-${++this.idCounter}`;
+    if (!this.data.has(entityType)) {
+      this.data.set(entityType, /* @__PURE__ */ new Map());
+    }
+    this.data.get(entityType).set(id, { ...data, id });
+    return { id };
+  }
+  async update(entityType, id, data) {
+    const collection = this.data.get(entityType);
+    if (collection?.has(id)) {
+      const existing = collection.get(id);
+      collection.set(id, { ...existing, ...data });
+    }
+  }
+  async delete(entityType, id) {
+    this.data.get(entityType)?.delete(id);
+  }
+  async getById(entityType, id) {
+    return this.data.get(entityType)?.get(id) || null;
+  }
+  async list(entityType) {
+    const collection = this.data.get(entityType);
+    return collection ? Array.from(collection.values()) : [];
+  }
+  /**
+   * Snapshot the entire store as a plain object (entityType → rows).
+   * Useful for feeding a fresh render-time binding layer with the
+   * current persistence view.
+   */
+  snapshot() {
+    const out = {};
+    for (const [entityType, collection] of this.data) {
+      out[entityType] = Array.from(collection.values());
+    }
+    return out;
+  }
+};
+
+export { EffectExecutor, EventBus, HANDLER_MANIFEST, InMemoryPersistence, MockPersistenceAdapter, StateMachineManager, containsBindings, createContextFromBindings, createInitialTraitState, createMockPersistence, createTestExecutor, createUnifiedLoader, extractBindings, findInitialState, findTransition, getIsolatedCollectionName, getNamespacedEvent, interpolateProps, interpolateValue, isBrowser, isElectron, isNamespacedEvent, isNode, normalizeEventKey, parseNamespacedEvent, preprocessSchema, processEvent };
+//# sourceMappingURL=chunk-RCWMQH7Y.js.map
+//# sourceMappingURL=chunk-RCWMQH7Y.js.map