fauxbase 0.1.0

package/dist/index.cjs

@@ -0,0 +1,608 @@
+'use strict';
+
+// src/errors.ts
+var FauxbaseError = class extends Error {
+  code;
+  details;
+  constructor(message, code, details) {
+    super(message);
+    this.name = "FauxbaseError";
+    this.code = code;
+    this.details = details;
+  }
+  toJSON() {
+    return { error: this.message, code: this.code, details: this.details };
+  }
+};
+var NotFoundError = class extends FauxbaseError {
+  constructor(message = "Resource not found") {
+    super(message, "NOT_FOUND");
+    this.name = "NotFoundError";
+  }
+};
+var ConflictError = class extends FauxbaseError {
+  constructor(message = "Resource conflict") {
+    super(message, "CONFLICT");
+    this.name = "ConflictError";
+  }
+};
+var ValidationError = class extends FauxbaseError {
+  constructor(message = "Validation failed", details) {
+    super(message, "VALIDATION", details);
+    this.name = "ValidationError";
+  }
+};
+var ForbiddenError = class extends FauxbaseError {
+  constructor(message = "Access forbidden") {
+    super(message, "FORBIDDEN");
+    this.name = "ForbiddenError";
+  }
+};
+
+// src/registry.ts
+var fieldRegistry = /* @__PURE__ */ new Map();
+var relationRegistry = /* @__PURE__ */ new Map();
+var computedRegistry = /* @__PURE__ */ new Map();
+var hookRegistry = /* @__PURE__ */ new Map();
+function registerField(target, propertyKey, options) {
+  if (!fieldRegistry.has(target)) fieldRegistry.set(target, /* @__PURE__ */ new Map());
+  fieldRegistry.get(target).set(propertyKey, options);
+}
+function registerRelation(target, propertyKey, entityName) {
+  if (!relationRegistry.has(target)) relationRegistry.set(target, /* @__PURE__ */ new Map());
+  relationRegistry.get(target).set(propertyKey, entityName);
+}
+function registerComputed(target, propertyKey, fn) {
+  if (!computedRegistry.has(target)) computedRegistry.set(target, /* @__PURE__ */ new Map());
+  computedRegistry.get(target).set(propertyKey, fn);
+}
+function registerHook(target, hookType, methodName) {
+  if (!hookRegistry.has(target)) hookRegistry.set(target, /* @__PURE__ */ new Map());
+  const hooks = hookRegistry.get(target);
+  if (!hooks.has(hookType)) hooks.set(hookType, []);
+  hooks.get(hookType).push(methodName);
+}
+function getFieldMeta(target) {
+  return fieldRegistry.get(target) ?? /* @__PURE__ */ new Map();
+}
+function getComputedMeta(target) {
+  return computedRegistry.get(target) ?? /* @__PURE__ */ new Map();
+}
+function getHooks(target, hookType) {
+  return hookRegistry.get(target)?.get(hookType) ?? [];
+}
+
+// src/entity.ts
+var Entity = class {
+};
+function field(options = {}) {
+  return (target, propertyKey) => {
+    registerField(target.constructor, propertyKey, options);
+  };
+}
+function relation(entityName) {
+  return (target, propertyKey) => {
+    registerRelation(target.constructor, propertyKey, entityName);
+  };
+}
+function computed(fn) {
+  return (target, propertyKey) => {
+    registerComputed(target.constructor, propertyKey, fn);
+  };
+}
+function applyDefaults(data, entityClass) {
+  const fieldMeta = getFieldMeta(entityClass);
+  const result = { ...data };
+  for (const [fieldName, options] of fieldMeta) {
+    if (result[fieldName] === void 0 && options.default !== void 0) {
+      result[fieldName] = typeof options.default === "function" ? options.default() : options.default;
+    }
+  }
+  return result;
+}
+function validateEntity(data, entityClass, isCreate) {
+  const fieldMeta = getFieldMeta(entityClass);
+  const errors = {};
+  for (const [fieldName, options] of fieldMeta) {
+    const value = data[fieldName];
+    if (isCreate && options.required && (value === void 0 || value === null || value === "")) {
+      errors[fieldName] = `${fieldName} is required`;
+    }
+    if (value !== void 0 && value !== null) {
+      if (options.min !== void 0 && typeof value === "number" && value < options.min) {
+        errors[fieldName] = `${fieldName} must be >= ${options.min}`;
+      }
+      if (options.max !== void 0 && typeof value === "number" && value > options.max) {
+        errors[fieldName] = `${fieldName} must be <= ${options.max}`;
+      }
+    }
+  }
+  if (Object.keys(errors).length > 0) {
+    throw new ValidationError("Validation failed", errors);
+  }
+}
+function applyComputedFields(data, entityClass) {
+  const computedMeta = getComputedMeta(entityClass);
+  if (computedMeta.size === 0) return data;
+  const result = { ...data };
+  for (const [key, fn] of computedMeta) {
+    Object.defineProperty(result, key, {
+      get: () => fn(result),
+      enumerable: true,
+      configurable: true
+    });
+  }
+  return result;
+}
+
+// src/service.ts
+function beforeCreate() {
+  return (target, propertyKey) => {
+    registerHook(target.constructor, "beforeCreate", propertyKey);
+  };
+}
+function beforeUpdate() {
+  return (target, propertyKey) => {
+    registerHook(target.constructor, "beforeUpdate", propertyKey);
+  };
+}
+function afterCreate() {
+  return (target, propertyKey) => {
+    registerHook(target.constructor, "afterCreate", propertyKey);
+  };
+}
+function afterUpdate() {
+  return (target, propertyKey) => {
+    registerHook(target.constructor, "afterUpdate", propertyKey);
+  };
+}
+var Service = class {
+  driver;
+  resourceName;
+  /** @internal — called by createClient to wire the service */
+  _init(driver, resourceName) {
+    this.driver = driver;
+    this.resourceName = resourceName;
+  }
+  async list(query = {}) {
+    return this.driver.list(this.resourceName, query);
+  }
+  async get(id) {
+    return this.driver.get(this.resourceName, id);
+  }
+  async create(data) {
+    const allItems = (await this.driver.list(this.resourceName, {})).items;
+    await this.runHooks("beforeCreate", data, allItems);
+    const result = await this.driver.create(this.resourceName, data);
+    await this.runHooks("afterCreate", result.data);
+    return result;
+  }
+  async update(id, data) {
+    await this.runHooks("beforeUpdate", id, data);
+    const result = await this.driver.update(this.resourceName, id, data);
+    await this.runHooks("afterUpdate", result.data);
+    return result;
+  }
+  async delete(id) {
+    return this.driver.delete(this.resourceName, id);
+  }
+  async count(filter) {
+    return this.driver.count(this.resourceName, filter);
+  }
+  get bulk() {
+    return {
+      create: (items) => this.driver.bulkCreate(this.resourceName, items),
+      update: (updates) => this.driver.bulkUpdate(this.resourceName, updates),
+      delete: (ids) => this.driver.bulkDelete(this.resourceName, ids)
+    };
+  }
+  async runHooks(hookType, ...args) {
+    const methods = getHooks(this.constructor, hookType);
+    for (const methodName of methods) {
+      await this[methodName](...args);
+    }
+  }
+};
+
+// src/query-engine.ts
+var OPERATORS = [
+  "startswith",
+  "endswith",
+  "contains",
+  "between",
+  "isnull",
+  "like",
+  "gte",
+  "lte",
+  "gt",
+  "lt",
+  "ne",
+  "in",
+  "eq"
+];
+function parseFilterKey(key) {
+  for (const op of OPERATORS) {
+    const suffix = `__${op}`;
+    if (key.endsWith(suffix)) {
+      return { field: key.slice(0, -suffix.length), operator: op };
+    }
+  }
+  return { field: key, operator: "eq" };
+}
+function matchOperator(itemValue, operator, filterValue) {
+  if (operator === "isnull") {
+    return filterValue ? itemValue === null || itemValue === void 0 : itemValue !== null && itemValue !== void 0;
+  }
+  if (itemValue === null || itemValue === void 0) return false;
+  switch (operator) {
+    case "eq":
+      return itemValue === filterValue;
+    case "ne":
+      return itemValue !== filterValue;
+    case "gt":
+      return itemValue > filterValue;
+    case "gte":
+      return itemValue >= filterValue;
+    case "lt":
+      return itemValue < filterValue;
+    case "lte":
+      return itemValue <= filterValue;
+    case "like":
+    case "contains":
+      return String(itemValue).toLowerCase().includes(String(filterValue).toLowerCase());
+    case "startswith":
+      return String(itemValue).toLowerCase().startsWith(String(filterValue).toLowerCase());
+    case "endswith":
+      return String(itemValue).toLowerCase().endsWith(String(filterValue).toLowerCase());
+    case "between":
+      return Array.isArray(filterValue) && itemValue >= filterValue[0] && itemValue <= filterValue[1];
+    case "in":
+      return Array.isArray(filterValue) && filterValue.includes(itemValue);
+    default:
+      return false;
+  }
+}
+function applyFilters(items, filter) {
+  return items.filter((item) => {
+    for (const [key, value] of Object.entries(filter)) {
+      const { field: field2, operator } = parseFilterKey(key);
+      if (!matchOperator(item[field2], operator, value)) return false;
+    }
+    return true;
+  });
+}
+function applySort(items, sort) {
+  if (!sort) return items;
+  return [...items].sort((a, b) => {
+    const aVal = a[sort.field];
+    const bVal = b[sort.field];
+    if (aVal === bVal) return 0;
+    if (aVal === null || aVal === void 0) return 1;
+    if (bVal === null || bVal === void 0) return -1;
+    const cmp = aVal < bVal ? -1 : 1;
+    return sort.direction === "desc" ? -cmp : cmp;
+  });
+}
+function applyPagination(items, page = 1, size = 20) {
+  const totalItems = items.length;
+  const totalPages = size > 0 ? Math.ceil(totalItems / size) : 0;
+  const start = (page - 1) * size;
+  const paged = items.slice(start, start + size);
+  return {
+    items: paged,
+    meta: { page, size, totalItems, totalPages }
+  };
+}
+function executeQuery(items, query) {
+  let result = items;
+  result = result.filter((item) => !item.deletedAt);
+  if (query.filter) {
+    result = applyFilters(result, query.filter);
+  }
+  result = applySort(result, query.sort);
+  return applyPagination(result, query.page, query.size);
+}
+
+// src/drivers/local.ts
+function generateUUID() {
+  if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") {
+    return crypto.randomUUID();
+  }
+  return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
+    const r = Math.random() * 16 | 0;
+    const v = c === "x" ? r : r & 3 | 8;
+    return v.toString(16);
+  });
+}
+var MemoryStorage = class {
+  data = /* @__PURE__ */ new Map();
+  meta = /* @__PURE__ */ new Map();
+  getAll(resource) {
+    const store = this.data.get(resource);
+    return store ? Array.from(store.values()) : [];
+  }
+  getById(resource, id) {
+    return this.data.get(resource)?.get(id);
+  }
+  set(resource, id, data) {
+    if (!this.data.has(resource)) this.data.set(resource, /* @__PURE__ */ new Map());
+    this.data.get(resource).set(id, data);
+  }
+  remove(resource, id) {
+    this.data.get(resource)?.delete(id);
+  }
+  clear(resource) {
+    this.data.delete(resource);
+  }
+  getMeta(key) {
+    return this.meta.get(key) ?? null;
+  }
+  setMeta(key, value) {
+    this.meta.set(key, value);
+  }
+};
+var LS_PREFIX = "fauxbase:";
+var LS_INDEX_PREFIX = `${LS_PREFIX}__index:`;
+var LS_META_PREFIX = `${LS_PREFIX}__meta:`;
+var LocalStorageBackend = class {
+  getIndex(resource) {
+    const raw = localStorage.getItem(`${LS_INDEX_PREFIX}${resource}`);
+    return raw ? JSON.parse(raw) : [];
+  }
+  setIndex(resource, ids) {
+    localStorage.setItem(`${LS_INDEX_PREFIX}${resource}`, JSON.stringify(ids));
+  }
+  getAll(resource) {
+    const ids = this.getIndex(resource);
+    const items = [];
+    for (const id of ids) {
+      const raw = localStorage.getItem(`${LS_PREFIX}${resource}:${id}`);
+      if (raw) items.push(JSON.parse(raw));
+    }
+    return items;
+  }
+  getById(resource, id) {
+    const raw = localStorage.getItem(`${LS_PREFIX}${resource}:${id}`);
+    return raw ? JSON.parse(raw) : void 0;
+  }
+  set(resource, id, data) {
+    localStorage.setItem(`${LS_PREFIX}${resource}:${id}`, JSON.stringify(data));
+    const ids = this.getIndex(resource);
+    if (!ids.includes(id)) {
+      ids.push(id);
+      this.setIndex(resource, ids);
+    }
+  }
+  remove(resource, id) {
+    localStorage.removeItem(`${LS_PREFIX}${resource}:${id}`);
+    const ids = this.getIndex(resource);
+    this.setIndex(resource, ids.filter((i) => i !== id));
+  }
+  clear(resource) {
+    const ids = this.getIndex(resource);
+    for (const id of ids) {
+      localStorage.removeItem(`${LS_PREFIX}${resource}:${id}`);
+    }
+    localStorage.removeItem(`${LS_INDEX_PREFIX}${resource}`);
+  }
+  getMeta(key) {
+    return localStorage.getItem(`${LS_META_PREFIX}${key}`);
+  }
+  setMeta(key, value) {
+    localStorage.setItem(`${LS_META_PREFIX}${key}`, value);
+  }
+};
+var LocalDriver = class {
+  storage;
+  entityClasses = /* @__PURE__ */ new Map();
+  constructor(config) {
+    this.storage = config.persist === "localStorage" ? new LocalStorageBackend() : new MemoryStorage();
+  }
+  registerEntity(resource, entityClass) {
+    this.entityClasses.set(resource, entityClass);
+  }
+  async list(resource, query) {
+    const items = this.storage.getAll(resource);
+    const entityClass = this.entityClasses.get(resource);
+    const processed = entityClass ? items.map((item) => applyComputedFields(item, entityClass)) : items;
+    return executeQuery(processed, query);
+  }
+  async get(resource, id) {
+    const item = this.storage.getById(resource, id);
+    if (!item || item.deletedAt) {
+      throw new NotFoundError(`${resource} with id "${id}" not found`);
+    }
+    const entityClass = this.entityClasses.get(resource);
+    const data = entityClass ? applyComputedFields(item, entityClass) : item;
+    return { data };
+  }
+  async create(resource, data) {
+    const entityClass = this.entityClasses.get(resource);
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    let record = {
+      ...data,
+      id: data.id || generateUUID(),
+      createdAt: now,
+      updatedAt: now,
+      deletedAt: null,
+      version: 1
+    };
+    if (entityClass) {
+      record = applyDefaults(record, entityClass);
+      validateEntity(record, entityClass, true);
+    }
+    this.storage.set(resource, record.id, record);
+    const result = entityClass ? applyComputedFields(record, entityClass) : record;
+    return { data: result };
+  }
+  async update(resource, id, data) {
+    const existing = this.storage.getById(resource, id);
+    if (!existing || existing.deletedAt) {
+      throw new NotFoundError(`${resource} with id "${id}" not found`);
+    }
+    const entityClass = this.entityClasses.get(resource);
+    if (entityClass) {
+      validateEntity(data, entityClass, false);
+    }
+    const record = {
+      ...existing,
+      ...data,
+      id,
+      createdAt: existing.createdAt,
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      version: (existing.version || 0) + 1
+    };
+    this.storage.set(resource, id, record);
+    const result = entityClass ? applyComputedFields(record, entityClass) : record;
+    return { data: result };
+  }
+  async delete(resource, id) {
+    const existing = this.storage.getById(resource, id);
+    if (!existing || existing.deletedAt) {
+      throw new NotFoundError(`${resource} with id "${id}" not found`);
+    }
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const record = {
+      ...existing,
+      deletedAt: now,
+      updatedAt: now,
+      version: (existing.version || 0) + 1
+    };
+    this.storage.set(resource, id, record);
+    return { data: record };
+  }
+  async count(resource, filter) {
+    let items = this.storage.getAll(resource).filter((item) => !item.deletedAt);
+    if (filter) {
+      items = applyFilters(items, filter);
+    }
+    return items.length;
+  }
+  async bulkCreate(resource, data) {
+    const results = [];
+    for (const item of data) {
+      const { data: created } = await this.create(resource, item);
+      results.push(created);
+    }
+    return { data: results };
+  }
+  async bulkUpdate(resource, updates) {
+    const results = [];
+    for (const { id, data } of updates) {
+      const { data: updated } = await this.update(resource, id, data);
+      results.push(updated);
+    }
+    return { data: results };
+  }
+  async bulkDelete(resource, ids) {
+    let count = 0;
+    for (const id of ids) {
+      await this.delete(resource, id);
+      count++;
+    }
+    return { data: { count } };
+  }
+  // --- Seed management (synchronous) ---
+  seed(resource, data, entityClass) {
+    for (let i = 0; i < data.length; i++) {
+      const seedId = `seed:${resource}:${i}`;
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      const record = applyDefaults({
+        ...data[i],
+        id: seedId,
+        createdAt: now,
+        updatedAt: now,
+        deletedAt: null,
+        version: 1
+      }, entityClass);
+      this.storage.set(resource, seedId, record);
+    }
+  }
+  getSeedVersion() {
+    return this.storage.getMeta("_seedVersion");
+  }
+  setSeedVersion(version) {
+    this.storage.setMeta("_seedVersion", version);
+  }
+  clear(resource) {
+    this.storage.clear(resource);
+  }
+};
+
+// src/seed.ts
+function seed(entityClass, data) {
+  const entityName = entityClass.name.toLowerCase();
+  return { entityName, entityClass, data };
+}
+function computeSeedVersion(seeds) {
+  const content = JSON.stringify(
+    seeds.map((s) => ({ entity: s.entityName, data: s.data }))
+  );
+  return simpleHash(content);
+}
+function simpleHash(str) {
+  let hash = 0;
+  for (let i = 0; i < str.length; i++) {
+    const char = str.charCodeAt(i);
+    hash = (hash << 5) - hash + char;
+    hash = hash & hash;
+  }
+  return Math.abs(hash).toString(36);
+}
+
+// src/client.ts
+function createClient(config) {
+  const driverConfig = config.driver ?? { type: "local" };
+  const driver = createDriver(driverConfig);
+  const client = {};
+  for (const [name, ServiceClass] of Object.entries(config.services)) {
+    const instance = new ServiceClass();
+    instance._init(driver, name);
+    if (driver instanceof LocalDriver) {
+      driver.registerEntity(name, instance.entity);
+    }
+    client[name] = instance;
+  }
+  if (config.seeds && driver instanceof LocalDriver) {
+    applySeedsIfNeeded(driver, config.seeds);
+  }
+  return client;
+}
+function createDriver(config) {
+  switch (config.type) {
+    case "local":
+      return new LocalDriver(config);
+    case "http":
+      throw new Error("HttpDriver not implemented yet");
+    default:
+      throw new Error(`Unknown driver type: ${config.type}`);
+  }
+}
+function applySeedsIfNeeded(driver, seeds) {
+  const newVersion = computeSeedVersion(seeds);
+  const currentVersion = driver.getSeedVersion();
+  if (currentVersion === newVersion) return;
+  for (const seedDef of seeds) {
+    driver.seed(seedDef.entityName, seedDef.data, seedDef.entityClass);
+  }
+  driver.setSeedVersion(newVersion);
+}
+
+exports.ConflictError = ConflictError;
+exports.Entity = Entity;
+exports.FauxbaseError = FauxbaseError;
+exports.ForbiddenError = ForbiddenError;
+exports.NotFoundError = NotFoundError;
+exports.Service = Service;
+exports.ValidationError = ValidationError;
+exports.afterCreate = afterCreate;
+exports.afterUpdate = afterUpdate;
+exports.beforeCreate = beforeCreate;
+exports.beforeUpdate = beforeUpdate;
+exports.computed = computed;
+exports.createClient = createClient;
+exports.field = field;
+exports.relation = relation;
+exports.seed = seed;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map