@v-ibe/core 0.1.0

package/dist/data-management/cache/session-storage-cache.js

@@ -0,0 +1,242 @@
+import { Service } from "../../DI/decorators/service.js";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __knownSymbol = (name, symbol) => (symbol = Symbol[name]) ? symbol : Symbol.for("Symbol." + name);
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __decoratorStart = (base) => [, , , __create(null)];
+var __decoratorStrings = ["class", "method", "getter", "setter", "accessor", "field", "value", "get", "set"];
+var __expectFn = (fn) => fn !== void 0 && typeof fn !== "function" ? __typeError("Function expected") : fn;
+var __decoratorContext = (kind, name, done, metadata, fns) => ({ kind: __decoratorStrings[kind], name, metadata, addInitializer: (fn) => done._ ? __typeError("Already initialized") : fns.push(__expectFn(fn || null)) });
+var __decoratorMetadata = (array, target) => __defNormalProp(target, __knownSymbol("metadata"), array[3]);
+var __runInitializers = (array, flags, self, value) => {
+  for (var i = 0, fns = array[flags >> 1], n = fns && fns.length; i < n; i++) fns[i].call(self);
+  return value;
+};
+var __decorateElement = (array, flags, name, decorators, target, extra) => {
+  var it, done, ctx, k = flags & 7, p = false;
+  var j = 0;
+  var extraInitializers = array[j] || (array[j] = []);
+  var desc = k && (target = target.prototype, k < 5 && (k > 3 || !p) && __getOwnPropDesc(target, name));
+  __name(target, name);
+  for (var i = decorators.length - 1; i >= 0; i--) {
+    ctx = __decoratorContext(k, name, done = {}, array[3], extraInitializers);
+    it = (0, decorators[i])(target, ctx), done._ = 1;
+    __expectFn(it) && (target = it);
+  }
+  return __decoratorMetadata(array, target), desc && __defProp(target, name, desc), p ? k ^ 4 ? extra : desc : target;
+};
+var _SessionStorageCache_decorators, _init;
+_SessionStorageCache_decorators = [Service];
+class SessionStorageCache {
+  constructor() {
+    this.prefix = "cache";
+    this.tagIndexKey = "cache:tagIndex";
+  }
+  getStorageKey(key) {
+    return `${this.prefix}:${key}`;
+  }
+  getTagIndex() {
+    try {
+      const data = sessionStorage.getItem(this.tagIndexKey);
+      if (!data) {
+        return /* @__PURE__ */ new Map();
+      }
+      const parsed = JSON.parse(data);
+      return new Map(
+        Object.entries(parsed).map(([tag, keys]) => [tag, new Set(keys)])
+      );
+    } catch {
+      return /* @__PURE__ */ new Map();
+    }
+  }
+  saveTagIndex(tagIndex) {
+    try {
+      const obj = {};
+      tagIndex.forEach((keys, tag) => {
+        obj[tag] = Array.from(keys);
+      });
+      sessionStorage.setItem(this.tagIndexKey, JSON.stringify(obj));
+    } catch (error) {
+      console.error("[SessionStorageCache] Error saving tag index:", error);
+    }
+  }
+  get(key) {
+    try {
+      const storageKey = this.getStorageKey(key);
+      const item = sessionStorage.getItem(storageKey);
+      if (!item) {
+        return null;
+      }
+      const entry = JSON.parse(item);
+      const now = Date.now();
+      const age = now - entry.timestamp;
+      if (age > entry.ttl) {
+        this.delete(key);
+        return null;
+      }
+      return entry.value;
+    } catch (error) {
+      console.error("[SessionStorageCache] Error getting item:", error);
+      return null;
+    }
+  }
+  set(key, value, ttl, tags = []) {
+    try {
+      const storageKey = this.getStorageKey(key);
+      const entry = {
+        value,
+        timestamp: Date.now(),
+        ttl,
+        tags
+      };
+      sessionStorage.setItem(storageKey, JSON.stringify(entry));
+      if (tags.length > 0) {
+        const tagIndex = this.getTagIndex();
+        tags.forEach((tag) => {
+          if (!tagIndex.has(tag)) {
+            tagIndex.set(tag, /* @__PURE__ */ new Set());
+          }
+          tagIndex.get(tag).add(key);
+        });
+        this.saveTagIndex(tagIndex);
+      }
+    } catch (error) {
+      console.error("[SessionStorageCache] Error setting item:", error);
+      this.clearExpired();
+    }
+  }
+  delete(key) {
+    try {
+      const storageKey = this.getStorageKey(key);
+      const item = sessionStorage.getItem(storageKey);
+      if (item) {
+        const entry = JSON.parse(item);
+        if (entry.tags && entry.tags.length > 0) {
+          const tagIndex = this.getTagIndex();
+          entry.tags.forEach((tag) => {
+            tagIndex.get(tag)?.delete(key);
+            if (tagIndex.get(tag)?.size === 0) {
+              tagIndex.delete(tag);
+            }
+          });
+          this.saveTagIndex(tagIndex);
+        }
+      }
+      sessionStorage.removeItem(storageKey);
+    } catch (error) {
+      console.error("[SessionStorageCache] Error deleting item:", error);
+    }
+  }
+  clear() {
+    const keysToRemove = [];
+    for (let i = 0; i < sessionStorage.length; i++) {
+      const key = sessionStorage.key(i);
+      if (key && key.startsWith(`${this.prefix}:`)) {
+        keysToRemove.push(key);
+      }
+    }
+    keysToRemove.forEach((key) => sessionStorage.removeItem(key));
+    sessionStorage.removeItem(this.tagIndexKey);
+  }
+  invalidatePattern(pattern) {
+    const keysToRemove = [];
+    for (let i = 0; i < sessionStorage.length; i++) {
+      const storageKey = sessionStorage.key(i);
+      if (storageKey && storageKey.startsWith(`${this.prefix}:`)) {
+        const key = storageKey.substring(this.prefix.length + 1);
+        if (pattern.test(key)) {
+          keysToRemove.push(key);
+        }
+      }
+    }
+    keysToRemove.forEach((key) => this.delete(key));
+  }
+  invalidateTag(tag) {
+    const tagIndex = this.getTagIndex();
+    const keysToInvalidate = tagIndex.get(tag);
+    if (!keysToInvalidate) {
+      return;
+    }
+    const keys = Array.from(keysToInvalidate);
+    keys.forEach((key) => this.delete(key));
+  }
+  getKeysByTag(tag) {
+    const tagIndex = this.getTagIndex();
+    const keys = tagIndex.get(tag);
+    return keys ? Array.from(keys) : [];
+  }
+  updateByTags(tags, value) {
+    const tagIndex = this.getTagIndex();
+    const keysToUpdate = /* @__PURE__ */ new Set();
+    tags.forEach((tag) => {
+      const keys = tagIndex.get(tag);
+      if (keys) {
+        keys.forEach((key) => keysToUpdate.add(key));
+      }
+    });
+    keysToUpdate.forEach((key) => {
+      const storageKey = this.getStorageKey(key);
+      const item = sessionStorage.getItem(storageKey);
+      if (item) {
+        try {
+          const fullEntry = JSON.parse(item);
+          this.set(key, value, fullEntry.ttl, fullEntry.tags);
+        } catch (error) {
+          console.error(`[SessionStorageCache] Error parsing entry for ${key}:`, error);
+        }
+      }
+    });
+  }
+  invalidateTags(tags) {
+    const tagIndex = this.getTagIndex();
+    const keysToInvalidate = /* @__PURE__ */ new Set();
+    tags.forEach((tag) => {
+      const keys = tagIndex.get(tag);
+      if (keys) {
+        keys.forEach((key) => keysToInvalidate.add(key));
+      }
+    });
+    keysToInvalidate.forEach((key) => this.delete(key));
+  }
+  clearExpired() {
+    const now = Date.now();
+    const keysToRemove = [];
+    for (let i = 0; i < sessionStorage.length; i++) {
+      const storageKey = sessionStorage.key(i);
+      if (storageKey && storageKey.startsWith(`${this.prefix}:`)) {
+        try {
+          const item = sessionStorage.getItem(storageKey);
+          if (item) {
+            const entry = JSON.parse(item);
+            const age = now - entry.timestamp;
+            if (age > entry.ttl) {
+              const key = storageKey.substring(this.prefix.length + 1);
+              keysToRemove.push(key);
+            }
+          }
+        } catch (error) {
+          const key = storageKey.substring(this.prefix.length + 1);
+          keysToRemove.push(key);
+        }
+      }
+    }
+    keysToRemove.forEach((key) => this.delete(key));
+  }
+  /**
+   * Lifecycle hook - se ejecuta cuando el container se destruye
+   */
+  onDestroy() {
+    this.clearExpired();
+  }
+}
+_init = __decoratorStart();
+SessionStorageCache = __decorateElement(_init, 0, "SessionStorageCache", _SessionStorageCache_decorators, SessionStorageCache);
+__runInitializers(_init, 1, SessionStorageCache);
+export {
+  SessionStorageCache
+};

package/dist/data-management/cache/ttl.decorator.d.ts

@@ -0,0 +1,31 @@
+/**
+ * @TTL - Decorador para cachear resultados de métodos con time-to-live.
+ *
+ * IMPORTANTE: El método debe ser async o retornar una Promise.
+ *
+ * @param ttl - Time-to-live en milisegundos
+ *
+ * @example
+ * // Cache en memoria (default) por 5 segundos
+ * @TTL(5000)
+ * async getStores() {
+ *   return await fetch('/api/stores').then(r => r.json());
+ * }
+ *
+ * @example
+ * // Cache en localStorage por 1 hora
+ * @Cache(LocalStorageCache)
+ * @TTL(3600000)
+ * async getUserPreferences() {
+ *   return await fetch('/api/preferences').then(r => r.json());
+ * }
+ *
+ * @example
+ * // Cache con argumentos
+ * @Cache(LocalStorageCache)
+ * @TTL(5000)
+ * async getUserById(id: string) {
+ *   return await fetch(`/api/users/${id}`).then(r => r.json());
+ * }
+ */
+export declare function TTL(ttl: number): (originalMethod: Function, context: ClassMethodDecoratorContext) => (this: any, ...args: any[]) => Promise<any>;

package/dist/data-management/cache/ttl.decorator.js

@@ -0,0 +1,34 @@
+import { MemoryCache } from "./memory-cache.js";
+function generateCacheKey(instance, methodName, args) {
+  const className = instance.constructor.name;
+  if (args.length === 0) {
+    return `${className}:${methodName}`;
+  }
+  const argsKey = JSON.stringify(args);
+  return `${className}:${methodName}:${argsKey}`;
+}
+function TTL(ttl) {
+  return function(originalMethod, context) {
+    const methodName = String(context.name);
+    const wrappedMethod = async function(...args) {
+      this.constructor.name;
+      const metadata = context.metadata;
+      const ProviderClass = metadata.cacheProviders?.[methodName] || MemoryCache;
+      const tagExtractor = metadata.cacheTagExtractors?.[methodName];
+      const provider = this.__container.get(ProviderClass);
+      const cacheKey = generateCacheKey(this, methodName, args);
+      const cached = provider.get(cacheKey);
+      if (cached !== null) {
+        return cached;
+      }
+      const result = await originalMethod.apply(this, args);
+      const tags = tagExtractor ? tagExtractor(result, args) : [];
+      provider.set(cacheKey, result, ttl, tags);
+      return result;
+    };
+    return wrappedMethod;
+  };
+}
+export {
+  TTL
+};

package/dist/data-management/decorators/consume.d.ts

@@ -0,0 +1,29 @@
+import { Constructor } from '../store/types';
+/**
+ * @Consume - Decorador para métodos de Repository
+ *
+ * @param modelClass - La clase del modelo (ej: User, Article)
+ *
+ * @example
+ * @Service
+ * class UserRepository {
+ *   @Consume(User)
+ *   async findAll() {
+ *     const response = await fetch('/api/users');
+ *     return await response.json();
+ *   }
+ *
+ *   @Consume(User)
+ *   async findById(id: string) {
+ *     const response = await fetch(`/api/users/${id}`);
+ *     return await response.json();
+ *   }
+ * }
+ *
+ * // Uso:
+ * const users = await repo.findAll();
+ * // users es User[], no JSON
+ * // users ya están en el Store
+ * users[0].changeName('New Name'); // Métodos de dominio funcionan
+ */
+export declare function Consume<T>(modelClass: Constructor<T>): <This extends object, Args extends any[], Return>(originalMethod: (this: This, ...args: Args) => Promise<Return>, context: ClassMethodDecoratorContext<This, (this: This, ...args: Args) => Promise<Return>>) => (this: This, ...args: Args) => Promise<any>;

package/dist/data-management/decorators/consume.js

@@ -0,0 +1,28 @@
+import { EntityStore } from "../store/store.js";
+import { convertResponse } from "../store/json-to-model.js";
+function Consume(modelClass) {
+  return function(originalMethod, context) {
+    if (context.kind !== "method") {
+      throw new Error("@Consume can only be applied to methods");
+    }
+    const methodName = String(context.name);
+    return async function(...args) {
+      try {
+        const result = await originalMethod.apply(this, args);
+        if (result === null || result === void 0) {
+          return result;
+        }
+        const instances = convertResponse(modelClass, result);
+        const entityStore = this.__container.get(EntityStore);
+        entityStore.set(modelClass, instances);
+        return instances;
+      } catch (error) {
+        console.error(`[Consume] Error en ${methodName}():`, error);
+        throw error;
+      }
+    };
+  };
+}
+export {
+  Consume
+};

package/dist/data-management/decorators/id.d.ts

@@ -0,0 +1,28 @@
+/**
+ * @Id DECORATOR
+ *
+ * Marca un campo como el identificador único de la entidad.
+ * Cada @Model debe tener exactamente un campo con @Id.
+ *
+ * USO:
+ * @Model
+ * class User {
+ *   @Id id: string;
+ *   @Prop name: string;
+ * }
+ *
+ * IMPLEMENTACIÓN:
+ * Este decorador se ejecuta ANTES que @Model (los field decorators van primero).
+ * Por eso, almacenamos la información en context.metadata, que @Model podrá leer después.
+ */
+/**
+ * @Id - Decorador para marcar el campo identificador
+ *
+ * @example
+ * class User {
+ *   @Id id: string;           // Campo ID
+ *   @Id userId: string;       // También funciona con otros nombres
+ *   @Id _id: string;          // MongoDB style
+ * }
+ */
+export declare function Id<This extends object, Value extends string | number>(target: undefined, context: ClassFieldDecoratorContext<This, Value>): (this: This, initialValue: Value) => Value;

package/dist/data-management/decorators/id.js

@@ -0,0 +1,19 @@
+function Id(target, context) {
+  if (context.kind !== "field") {
+    throw new Error("@Id can only be applied to class fields");
+  }
+  const fieldName = String(context.name);
+  const metadata = context.metadata;
+  if (metadata.idField) {
+    throw new Error(
+      `Cannot have multiple @Id decorators in the same class. Found @Id on '${metadata.idField}' and '${fieldName}'.`
+    );
+  }
+  metadata.idField = fieldName;
+  return function(initialValue) {
+    return initialValue;
+  };
+}
+export {
+  Id
+};

package/dist/data-management/decorators/model.d.ts

@@ -0,0 +1,48 @@
+/**
+ * @Model DECORATOR
+ *
+ * Decorador de clase que registra un modelo en el Store.
+ * Se ejecuta DESPUÉS de @Id y @Prop, por lo que puede leer
+ * la metadata que estos decoradores dejaron.
+ *
+ * USO:
+ * @Model
+ * class User {
+ *   @Id id: string;
+ *   @Prop name: string;
+ *   @Prop email: string;
+ *
+ *   // Métodos de dominio
+ *   changeName(newName: string) {
+ *     this.name = newName;
+ *   }
+ * }
+ *
+ * RESPONSABILIDADES:
+ * 1. Leer metadata de @Id y @Prop
+ * 2. Validar que hay exactamente un @Id
+ * 3. Registrar metadata en el Store
+ * 4. Retornar la clase sin modificarla
+ */
+/**
+ * @Model - Decorador de clase para modelos de datos
+ *
+ * @example
+ * @Model
+ * class User {
+ *   @Id id: string;
+ *   @Prop name: string;
+ *
+ *   constructor(id: string, name: string) {
+ *     this.id = id;
+ *     this.name = name;
+ *   }
+ * }
+ *
+ * // Ahora el Store sabe sobre User
+ * const user = new User("1", "Julian");
+ * store.set(User, user);
+ */
+export declare function Model<T extends {
+    new (...args: any[]): {};
+}>(target: T, context: ClassDecoratorContext<T>): T;

package/dist/data-management/decorators/model.js

@@ -0,0 +1,24 @@
+import { registerModelMetadata } from "../store/store.js";
+function Model(target, context) {
+  if (context.kind !== "class") {
+    throw new Error("@Model can only be applied to classes");
+  }
+  const metadata = context.metadata;
+  const idField = metadata.idField;
+  if (!idField) {
+    throw new Error(
+      `@Model class ${target.name} must have exactly one field decorated with @Id`
+    );
+  }
+  const propFields = metadata.propFields || [];
+  const modelMetadata = {
+    modelClass: target,
+    idField,
+    propFields
+  };
+  registerModelMetadata(modelMetadata);
+  return target;
+}
+export {
+  Model
+};

package/dist/data-management/decorators/prop.d.ts

@@ -0,0 +1,43 @@
+/**
+ * @Prop DECORATOR
+ *
+ * Convierte un campo en una propiedad reactiva usando signals.
+ * Similar a @State, pero también registra el campo en la metadata del modelo.
+ *
+ * USO:
+ * @Model
+ * class User {
+ *   @Id id: string;
+ *   @Prop name: string;      // Reactivo
+ *   @Prop email: string;     // Reactivo
+ * }
+ *
+ * IMPLEMENTACIÓN:
+ * 1. Crea una Signal interna para almacenar el valor
+ * 2. Define getter/setter que usan la Signal
+ * 3. Define propiedad `$nombre` que expone la Signal
+ * 4. Registra el campo en metadata para que @Model lo sepa
+ *
+ * DIFERENCIA CON @State:
+ * @State es para componentes, @Prop es para entidades de datos.
+ * Ambos usan el mismo mecanismo interno (Signals).
+ */
+/**
+ * @Prop - Decorador para propiedades reactivas de modelos
+ *
+ * @example
+ * @Model
+ * class User {
+ *   @Id id: string;
+ *   @Prop name: string;
+ *   @Prop email: string;
+ *   @Prop age: number;
+ * }
+ *
+ * // Uso:
+ * const user = new User();
+ * user.name = "Julian";        // Setter actualiza la signal
+ * console.log(user.name);      // Getter lee de la signal
+ * console.log(user.$name);     // Acceso directo a la signal
+ */
+export declare function Prop<This extends object, Value>(target: undefined, context: ClassFieldDecoratorContext<This, Value>): (this: This, initialValue: Value) => Value;

package/dist/data-management/decorators/prop.js

@@ -0,0 +1,32 @@
+import { Signal } from "../../reactivity/signals/signal.js";
+function Prop(target, context) {
+  if (context.kind !== "field") {
+    throw new Error("@Prop can only be applied to class fields");
+  }
+  const fieldName = String(context.name);
+  const signalKey = Symbol(`prop_signal_${fieldName}`);
+  const signalPropName = `$${fieldName}`;
+  const metadata = context.metadata;
+  metadata.propFields ??= [];
+  metadata.propFields.push(fieldName);
+  return function(initialValue) {
+    const signal = new Signal(initialValue);
+    this[signalKey] = signal;
+    Object.defineProperty(this, fieldName, {
+      get: () => this[signalKey].get(),
+      set: (newValue) => this[signalKey].set(newValue),
+      enumerable: true,
+      configurable: true
+    });
+    Object.defineProperty(this, signalPropName, {
+      get: () => this[signalKey],
+      enumerable: false,
+      // No aparece en Object.keys()
+      configurable: true
+    });
+    return initialValue;
+  };
+}
+export {
+  Prop
+};

package/dist/data-management/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * DATA MANAGEMENT SYSTEM - Public API
+ *
+ * Este archivo expone la API pública del sistema de gestión de datos.
+ */
+export { EntityStore, registerModelMetadata, getModelMetadata } from './store/store';
+export { Model } from './decorators/model';
+export { Id } from './decorators/id';
+export { Prop } from './decorators/prop';
+export { Consume } from './decorators/consume';
+export { MemoryCache, LocalStorageCache, SessionStorageCache, Cache, TTL, CacheTags, CacheUpdate, CacheInvalidate } from './cache';
+export type { CacheProvider, CacheEntry, TagExtractor } from './cache';
+export type { Constructor, ModelMetadata, StoreEntity, Predicate, QueryResult, } from './store/types';

package/dist/data-management/store/json-to-model.d.ts

@@ -0,0 +1,45 @@
+import { Constructor } from './types';
+/**
+ * Convierte un objeto JSON plano en una instancia de modelo.
+ *
+ * @param modelClass - La clase del modelo (ej: User)
+ * @param data - Objeto JSON plano con los datos
+ * @returns Instancia del modelo con propiedades reactivas
+ *
+ * @example
+ * const json = { id: "1", name: "Julian", email: "j@example.com" };
+ * const user = jsonToModel(User, json);
+ * // user es una instancia de User con propiedades reactivas
+ */
+export declare function jsonToModel<T>(modelClass: Constructor<T>, data: Record<string, any>): T;
+/**
+ * Convierte un array de JSON en un array de instancias de modelo.
+ *
+ * @param modelClass - La clase del modelo
+ * @param dataArray - Array de objetos JSON
+ * @returns Array de instancias del modelo
+ *
+ * @example
+ * const jsonArray = [
+ *   { id: "1", name: "Julian" },
+ *   { id: "2", name: "Alice" }
+ * ];
+ * const users = jsonArrayToModels(User, jsonArray);
+ * // [User instance, User instance]
+ */
+export declare function jsonArrayToModels<T>(modelClass: Constructor<T>, dataArray: Record<string, any>[]): T[];
+/**
+ * Convierte cualquier respuesta (objeto o array) a modelo(s).
+ *
+ * @param modelClass - La clase del modelo
+ * @param response - Puede ser un objeto o un array
+ * @returns Instancia o array de instancias
+ *
+ * @example
+ * // Objeto único
+ * const user = convertResponse(User, { id: "1", name: "Julian" });
+ *
+ * // Array
+ * const users = convertResponse(User, [{ id: "1" }, { id: "2" }]);
+ */
+export declare function convertResponse<T>(modelClass: Constructor<T>, response: any): T | T[];

package/dist/data-management/store/json-to-model.js

@@ -0,0 +1,36 @@
+import { getModelMetadata } from "./store.js";
+function jsonToModel(modelClass, data) {
+  const metadata = getModelMetadata(modelClass);
+  if (!metadata) {
+    throw new Error(
+      `Cannot convert to model: ${modelClass.name} is not decorated with @Model`
+    );
+  }
+  const instance = new modelClass();
+  Object.keys(data).forEach((key) => {
+    if (data[key] !== void 0 && data[key] !== null) {
+      instance[key] = data[key];
+    }
+  });
+  return instance;
+}
+function jsonArrayToModels(modelClass, dataArray) {
+  return dataArray.map((data) => jsonToModel(modelClass, data));
+}
+function convertResponse(modelClass, response) {
+  if (response === null || response === void 0) {
+    return response;
+  }
+  if (Array.isArray(response)) {
+    return jsonArrayToModels(modelClass, response);
+  }
+  if (typeof response === "object") {
+    return jsonToModel(modelClass, response);
+  }
+  return response;
+}
+export {
+  convertResponse,
+  jsonArrayToModels,
+  jsonToModel
+};