schemock 0.0.1

package/dist/runtime/index.js

@@ -0,0 +1,1270 @@
+'use strict';
+
+var msw = require('msw');
+
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/runtime/handlers.ts
+var handlers_exports = {};
+__export(handlers_exports, {
+  createHandlers: () => createHandlers
+});
+function createHandlers(schemas, adapter, options) {
+  const handlers = [];
+  const baseUrl = options?.baseUrl ?? "/api";
+  for (const schema of schemas) {
+    const entityPath = getEntityPath(schema, baseUrl);
+    handlers.push(createListHandler(schema, entityPath, adapter));
+    handlers.push(createGetHandler(schema, entityPath, adapter));
+    handlers.push(createCreateHandler(schema, entityPath, adapter));
+    handlers.push(createUpdateHandler(schema, entityPath, adapter, "PUT"));
+    handlers.push(createUpdateHandler(schema, entityPath, adapter, "PATCH"));
+    handlers.push(createDeleteHandler(schema, entityPath, adapter));
+    if (schema.api?.operations) {
+      handlers.push(
+        ...createCustomHandlers(schema, entityPath, adapter)
+      );
+    }
+  }
+  return handlers;
+}
+function getEntityPath(schema, baseUrl) {
+  if (schema.api?.basePath) {
+    return schema.api.basePath;
+  }
+  const plural = schema.name.endsWith("s") ? schema.name : `${schema.name}s`;
+  return `${baseUrl}/${plural}`;
+}
+function createListHandler(schema, path, adapter) {
+  return msw.http.get(path, async ({ request }) => {
+    const url = new URL(request.url);
+    const ctx = {
+      entity: schema.name,
+      endpoint: path,
+      params: {},
+      filter: parseQueryFilter(url.searchParams),
+      limit: parseNumber(url.searchParams.get("limit")),
+      offset: parseNumber(url.searchParams.get("offset")),
+      orderBy: parseOrderBy(url.searchParams.get("orderBy"))
+    };
+    const result = await adapter.findMany(ctx);
+    if (result.error) {
+      return msw.HttpResponse.json(
+        { error: result.error.message },
+        { status: 500 }
+      );
+    }
+    return msw.HttpResponse.json({
+      data: result.data,
+      meta: result.meta
+    });
+  });
+}
+function createGetHandler(schema, path, adapter) {
+  return msw.http.get(`${path}/:id`, async ({ params }) => {
+    const ctx = {
+      entity: schema.name,
+      endpoint: path,
+      params: { id: params.id }
+    };
+    const result = await adapter.findOne(ctx);
+    if (result.error) {
+      return msw.HttpResponse.json(
+        { error: result.error.message },
+        { status: 404 }
+      );
+    }
+    if (!result.data) {
+      return msw.HttpResponse.json(
+        { error: `${schema.name} not found` },
+        { status: 404 }
+      );
+    }
+    return msw.HttpResponse.json({ data: result.data });
+  });
+}
+function createCreateHandler(schema, path, adapter) {
+  return msw.http.post(path, async ({ request }) => {
+    const body = await request.json();
+    const ctx = {
+      entity: schema.name,
+      endpoint: path,
+      data: body
+    };
+    const result = await adapter.create(ctx);
+    if (result.error) {
+      return msw.HttpResponse.json(
+        { error: result.error.message },
+        { status: 400 }
+      );
+    }
+    return msw.HttpResponse.json({ data: result.data }, { status: 201 });
+  });
+}
+function createUpdateHandler(schema, path, adapter, method) {
+  const handler = method === "PUT" ? msw.http.put : msw.http.patch;
+  return handler(`${path}/:id`, async ({ params, request }) => {
+    const body = await request.json();
+    const ctx = {
+      entity: schema.name,
+      endpoint: path,
+      params: { id: params.id },
+      data: body
+    };
+    const result = await adapter.update(ctx);
+    if (result.error) {
+      return msw.HttpResponse.json(
+        { error: result.error.message },
+        { status: 400 }
+      );
+    }
+    if (!result.data) {
+      return msw.HttpResponse.json(
+        { error: `${schema.name} not found` },
+        { status: 404 }
+      );
+    }
+    return msw.HttpResponse.json({ data: result.data });
+  });
+}
+function createDeleteHandler(schema, path, adapter) {
+  return msw.http.delete(`${path}/:id`, async ({ params }) => {
+    const ctx = {
+      entity: schema.name,
+      endpoint: path,
+      params: { id: params.id }
+    };
+    const result = await adapter.delete(ctx);
+    if (result.error) {
+      return msw.HttpResponse.json(
+        { error: result.error.message },
+        { status: 400 }
+      );
+    }
+    return new msw.HttpResponse(null, { status: 204 });
+  });
+}
+function createCustomHandlers(schema, basePath, adapter) {
+  const handlers = [];
+  const operations = schema.api?.operations || {};
+  for (const [name, config] of Object.entries(operations)) {
+    if (typeof config === "boolean") continue;
+    if (!config || typeof config !== "object") continue;
+    const customConfig = config;
+    const method = customConfig.method?.toLowerCase() || "get";
+    const path = `${basePath}${customConfig.path || `/${name}`}`;
+    const httpMethod = msw.http[method];
+    if (typeof httpMethod !== "function") continue;
+    handlers.push(
+      httpMethod(path, async ({ request, params }) => {
+        const ctx = {
+          entity: schema.name,
+          endpoint: path,
+          operation: name,
+          params
+        };
+        if (method === "post" || method === "put" || method === "patch") {
+          ctx.data = await request.json();
+        }
+        if (adapter.custom) {
+          const result = await adapter.custom(ctx);
+          if (result.error) {
+            return msw.HttpResponse.json(
+              { error: result.error.message },
+              { status: 400 }
+            );
+          }
+          return msw.HttpResponse.json({ data: result.data });
+        }
+        return msw.HttpResponse.json(
+          { error: "Custom operations not supported by adapter" },
+          { status: 501 }
+        );
+      })
+    );
+  }
+  return handlers;
+}
+function parseQueryFilter(params) {
+  const filter = {};
+  let hasFilter = false;
+  for (const [key, value] of params.entries()) {
+    if (["limit", "offset", "orderBy", "select"].includes(key)) continue;
+    if (key.startsWith("filter[") && key.endsWith("]")) {
+      const field = key.slice(7, -1);
+      filter[field] = parseValue(value);
+      hasFilter = true;
+    } else if (!key.includes("[")) {
+      filter[key] = parseValue(value);
+      hasFilter = true;
+    }
+  }
+  return hasFilter ? filter : void 0;
+}
+function parseOrderBy(value) {
+  if (!value) return void 0;
+  const orderBy = {};
+  for (const part of value.split(",")) {
+    const [field, direction] = part.split(":");
+    if (field) {
+      orderBy[field] = direction === "desc" ? "desc" : "asc";
+    }
+  }
+  return Object.keys(orderBy).length > 0 ? orderBy : void 0;
+}
+function parseNumber(value) {
+  if (!value) return void 0;
+  const num = parseInt(value, 10);
+  return isNaN(num) ? void 0 : num;
+}
+function parseValue(value) {
+  if (value === "true") return true;
+  if (value === "false") return false;
+  const num = Number(value);
+  if (!isNaN(num)) return num;
+  return value;
+}
+var init_handlers = __esm({
+  "src/runtime/handlers.ts"() {
+  }
+});
+
+// src/runtime/resolver/registry.ts
+var SchemaRegistry = class {
+  entities = /* @__PURE__ */ new Map();
+  views = /* @__PURE__ */ new Map();
+  /**
+   * Register an entity schema
+   * @param schema - The entity schema to register
+   */
+  register(schema) {
+    if (this.entities.has(schema.name)) {
+      console.warn(`Schema '${schema.name}' is already registered. Overwriting.`);
+    }
+    this.entities.set(schema.name, schema);
+  }
+  /**
+   * Register a view schema
+   * @param view - The view schema to register
+   */
+  registerView(view) {
+    if (this.views.has(view.name)) {
+      console.warn(`View '${view.name}' is already registered. Overwriting.`);
+    }
+    this.views.set(view.name, view);
+  }
+  /**
+   * Get an entity schema by name
+   * @param entityName - The entity name
+   * @returns EntitySchema or undefined if not found
+   */
+  get(entityName) {
+    return this.entities.get(entityName);
+  }
+  /**
+   * Get an entity schema by name, throws if not found
+   * @param entityName - The entity name
+   * @returns EntitySchema
+   * @throws Error if entity not found
+   */
+  getOrThrow(entityName) {
+    const schema = this.entities.get(entityName);
+    if (!schema) {
+      throw new Error(`Entity schema '${entityName}' not found. Did you forget to register it?`);
+    }
+    return schema;
+  }
+  /**
+   * Get a view schema by name
+   * @param viewName - The view name
+   * @returns ViewSchema or undefined if not found
+   */
+  getView(viewName) {
+    return this.views.get(viewName);
+  }
+  /**
+   * Get a view schema by name, throws if not found
+   * @param viewName - The view name
+   * @returns ViewSchema
+   * @throws Error if view not found
+   */
+  getViewOrThrow(viewName) {
+    const view = this.views.get(viewName);
+    if (!view) {
+      throw new Error(`View schema '${viewName}' not found. Did you forget to register it?`);
+    }
+    return view;
+  }
+  /**
+   * Get all registered entity schemas
+   * @returns Array of all entity schemas
+   */
+  getAll() {
+    return Array.from(this.entities.values());
+  }
+  /**
+   * Get all registered view schemas
+   * @returns Array of all view schemas
+   */
+  getAllViews() {
+    return Array.from(this.views.values());
+  }
+  /**
+   * Check if an entity schema is registered
+   * @param entityName - The entity name
+   * @returns true if registered
+   */
+  has(entityName) {
+    return this.entities.has(entityName);
+  }
+  /**
+   * Check if a view schema is registered
+   * @param viewName - The view name
+   * @returns true if registered
+   */
+  hasView(viewName) {
+    return this.views.has(viewName);
+  }
+  /**
+   * Get all relations for an entity
+   * @param entityName - The entity name
+   * @returns Array of relation definitions with their names
+   */
+  getRelationsFor(entityName) {
+    const schema = this.entities.get(entityName);
+    if (!schema || !schema.relations) {
+      return [];
+    }
+    return Object.entries(schema.relations).map(([name, relation]) => ({
+      name,
+      relation
+    }));
+  }
+  /**
+   * Get all entities that have a relation to a target entity
+   * @param targetEntityName - The target entity name
+   * @returns Array of entity names that reference the target
+   */
+  getEntitiesReferencingEntity(targetEntityName) {
+    const result = [];
+    for (const [entityName, schema] of this.entities) {
+      if (schema.relations) {
+        for (const relation of Object.values(schema.relations)) {
+          if (relation.target === targetEntityName) {
+            result.push(entityName);
+            break;
+          }
+        }
+      }
+    }
+    return result;
+  }
+  /**
+   * Get entity names in dependency order (topological sort)
+   * Entities with no dependencies come first
+   * @returns Array of entity names in order
+   */
+  getEntityOrder() {
+    const visited = /* @__PURE__ */ new Set();
+    const result = [];
+    const visit = (entityName) => {
+      if (visited.has(entityName)) return;
+      visited.add(entityName);
+      const schema = this.entities.get(entityName);
+      if (schema?.relations) {
+        for (const relation of Object.values(schema.relations)) {
+          if (this.entities.has(relation.target)) {
+            visit(relation.target);
+          }
+        }
+      }
+      result.push(entityName);
+    };
+    for (const entityName of this.entities.keys()) {
+      visit(entityName);
+    }
+    return result;
+  }
+  /**
+   * Clear all registered schemas
+   */
+  clear() {
+    this.entities.clear();
+    this.views.clear();
+  }
+  /**
+   * Get entity count
+   */
+  get entityCount() {
+    return this.entities.size;
+  }
+  /**
+   * Get view count
+   */
+  get viewCount() {
+    return this.views.size;
+  }
+};
+var registry = new SchemaRegistry();
+
+// src/runtime/resolver/computed.ts
+function topologicalSort(fields, allComputed) {
+  const result = [];
+  const visited = /* @__PURE__ */ new Set();
+  const visiting = /* @__PURE__ */ new Set();
+  const fieldNames = new Set(fields.map(([name]) => name));
+  function visit(name) {
+    if (visited.has(name)) return;
+    if (visiting.has(name)) {
+      throw new Error(`Circular dependency detected in computed fields: ${name}`);
+    }
+    visiting.add(name);
+    const computed = allComputed[name];
+    if (computed?.dependsOn) {
+      for (const dep of computed.dependsOn) {
+        if (allComputed[dep] && fieldNames.has(dep)) {
+          visit(dep);
+        }
+      }
+    }
+    visiting.delete(name);
+    visited.add(name);
+    const field = fields.find(([n]) => n === name);
+    if (field) {
+      result.push(field);
+    }
+  }
+  for (const [name] of fields) {
+    visit(name);
+  }
+  return result;
+}
+var computeCache = /* @__PURE__ */ new Map();
+function clearComputeCache() {
+  computeCache.clear();
+}
+function resolveComputedField(entity, fieldName, computed, db, context) {
+  const entityId = entity.id;
+  const cacheKey = `${entityId}:${fieldName}`;
+  if (computeCache.has(cacheKey)) {
+    return computeCache.get(cacheKey);
+  }
+  let value;
+  if (context.mode === "seed" && computed.mock) {
+    value = computed.mock();
+  } else {
+    value = computed.resolve(entity, db, context);
+  }
+  if (value instanceof Promise) {
+    return value.then((resolved) => {
+      computeCache.set(cacheKey, resolved);
+      return resolved;
+    });
+  }
+  computeCache.set(cacheKey, value);
+  return value;
+}
+async function resolveComputedFields(entity, schema, db, context) {
+  if (!schema.computed || Object.keys(schema.computed).length === 0) {
+    return entity;
+  }
+  const computedFields = Object.entries(schema.computed);
+  const sorted = topologicalSort(computedFields, schema.computed);
+  for (const [fieldName, computed] of sorted) {
+    const value = await resolveComputedField(entity, fieldName, computed, db, context);
+    entity[fieldName] = value;
+  }
+  return entity;
+}
+function resolveComputedFieldsSync(entity, schema, context) {
+  if (!schema.computed || Object.keys(schema.computed).length === 0) {
+    return entity;
+  }
+  const computedFields = Object.entries(schema.computed);
+  const sorted = topologicalSort(computedFields, schema.computed);
+  for (const [fieldName, computed] of sorted) {
+    if (computed.mock) {
+      entity[fieldName] = computed.mock();
+    }
+  }
+  return entity;
+}
+
+// src/runtime/resolver/relation.ts
+var DEFAULT_MAX_DEPTH = 3;
+async function resolveRelation(entity, relationName, relation, db, registry2, options = {}, currentDepth = 0) {
+  const maxDepth = options.depth ?? DEFAULT_MAX_DEPTH;
+  if (currentDepth >= maxDepth) {
+    return relation.type === "hasMany" ? [] : null;
+  }
+  switch (relation.type) {
+    case "hasOne":
+      return resolveHasOne(entity, relation, db, registry2, options, currentDepth);
+    case "hasMany":
+      return resolveHasMany(entity, relation, db, registry2, options, currentDepth);
+    case "belongsTo":
+      return resolveBelongsTo(entity, relation, db, registry2, options, currentDepth);
+    default:
+      throw new Error(`Unknown relation type: ${relation.type}`);
+  }
+}
+async function resolveHasOne(entity, relation, db, registry2, options, currentDepth) {
+  const targetDb = db[relation.target];
+  if (!targetDb) {
+    throw new Error(`Target entity '${relation.target}' not found in database`);
+  }
+  const foreignKey = relation.foreignKey || `${entity.constructor.name.toLowerCase()}Id`;
+  const entityId = entity.id;
+  const related = targetDb.findFirst({
+    where: {
+      [foreignKey]: { equals: entityId }
+    }
+  });
+  if (!related) return null;
+  const targetSchema = registry2.get(relation.target);
+  if (targetSchema) {
+    await resolveNestedRelations(
+      related,
+      targetSchema,
+      db,
+      registry2,
+      options,
+      currentDepth + 1
+    );
+  }
+  return related;
+}
+async function resolveHasMany(entity, relation, db, registry2, options, currentDepth) {
+  const targetDb = db[relation.target];
+  if (!targetDb) {
+    throw new Error(`Target entity '${relation.target}' not found in database`);
+  }
+  const foreignKey = relation.foreignKey || `${entity.constructor.name.toLowerCase()}Id`;
+  const entityId = entity.id;
+  const query = {
+    where: {
+      [foreignKey]: { equals: entityId }
+    }
+  };
+  const limit = options.limit ?? relation.limit;
+  if (limit) {
+    query.take = limit;
+  }
+  const orderBy = options.orderBy ?? relation.orderBy;
+  if (orderBy) {
+    query.orderBy = orderBy;
+  }
+  const results = targetDb.findMany(query);
+  const targetSchema = registry2.get(relation.target);
+  if (targetSchema) {
+    for (const item of results) {
+      await resolveNestedRelations(
+        item,
+        targetSchema,
+        db,
+        registry2,
+        options,
+        currentDepth + 1
+      );
+    }
+  }
+  return results;
+}
+async function resolveBelongsTo(entity, relation, db, registry2, options, currentDepth) {
+  const foreignKey = relation.foreignKey || `${relation.target}Id`;
+  const foreignKeyValue = entity[foreignKey];
+  if (!foreignKeyValue) return null;
+  const targetDb = db[relation.target];
+  if (!targetDb) {
+    throw new Error(`Target entity '${relation.target}' not found in database`);
+  }
+  const related = targetDb.findFirst({
+    where: { id: { equals: foreignKeyValue } }
+  });
+  if (!related) return null;
+  const targetSchema = registry2.get(relation.target);
+  if (targetSchema) {
+    await resolveNestedRelations(
+      related,
+      targetSchema,
+      db,
+      registry2,
+      options,
+      currentDepth + 1
+    );
+  }
+  return related;
+}
+async function resolveNestedRelations(entity, schema, db, registry2, options, currentDepth) {
+  if (!schema.relations) return;
+  const include = options.include ?? [];
+  for (const [relationName, relation] of Object.entries(schema.relations)) {
+    const shouldLoad = relation.eager || include.includes(relationName) || include.some((inc) => inc.startsWith(`${relationName}.`));
+    if (shouldLoad) {
+      const nestedIncludes = include.filter((inc) => inc.startsWith(`${relationName}.`)).map((inc) => inc.replace(`${relationName}.`, ""));
+      entity[relationName] = await resolveRelation(
+        entity,
+        relationName,
+        relation,
+        db,
+        registry2,
+        { ...options, include: nestedIncludes },
+        currentDepth
+      );
+    }
+  }
+}
+async function resolveRelations(entity, schema, db, registry2, options = {}) {
+  await resolveNestedRelations(entity, schema, db, registry2, options, 0);
+  return entity;
+}
+async function eagerLoadRelations(entities, schema, db, registry2, options = {}) {
+  if (!schema.relations || entities.length === 0) {
+    return entities;
+  }
+  const include = options.include ?? [];
+  for (const [relationName, relation] of Object.entries(schema.relations)) {
+    const shouldLoad = relation.eager || include.includes(relationName) || include.some((inc) => inc.startsWith(`${relationName}.`));
+    if (!shouldLoad) continue;
+    if (relation.type === "belongsTo") {
+      await batchLoadBelongsTo(entities, relationName, relation, db, registry2, options);
+    } else if (relation.type === "hasOne") {
+      await batchLoadHasOne(entities, relationName, relation, db, registry2, options);
+    } else if (relation.type === "hasMany") {
+      for (const entity of entities) {
+        entity[relationName] = await resolveRelation(entity, relationName, relation, db, registry2, options);
+      }
+    }
+  }
+  return entities;
+}
+async function batchLoadBelongsTo(entities, relationName, relation, db, registry2, options) {
+  const foreignKey = relation.foreignKey || `${relation.target}Id`;
+  const targetDb = db[relation.target];
+  const foreignKeyValues = [...new Set(entities.map((e) => e[foreignKey]).filter(Boolean))];
+  if (foreignKeyValues.length === 0) {
+    entities.forEach((e) => e[relationName] = null);
+    return;
+  }
+  const relatedEntities = targetDb.findMany({
+    where: {
+      id: { in: foreignKeyValues }
+    }
+  });
+  const lookup = new Map(relatedEntities.map((r) => [r.id, r]));
+  for (const entity of entities) {
+    const fkValue = entity[foreignKey];
+    entity[relationName] = fkValue ? lookup.get(fkValue) ?? null : null;
+  }
+  const targetSchema = registry2.get(relation.target);
+  if (targetSchema) {
+    const nestedIncludes = (options.include ?? []).filter((inc) => inc.startsWith(`${relationName}.`)).map((inc) => inc.replace(`${relationName}.`, ""));
+    if (nestedIncludes.length > 0) {
+      await eagerLoadRelations(relatedEntities, targetSchema, db, registry2, {
+        ...options,
+        include: nestedIncludes
+      });
+    }
+  }
+}
+async function batchLoadHasOne(entities, relationName, relation, db, registry2, options) {
+  const foreignKey = relation.foreignKey || "id";
+  const targetDb = db[relation.target];
+  const entityIds = entities.map((e) => e.id).filter(Boolean);
+  if (entityIds.length === 0) {
+    entities.forEach((e) => e[relationName] = null);
+    return;
+  }
+  const relatedEntities = targetDb.findMany({
+    where: {
+      [foreignKey]: { in: entityIds }
+    }
+  });
+  const lookup = new Map(relatedEntities.map((r) => [r[foreignKey], r]));
+  for (const entity of entities) {
+    entity[relationName] = lookup.get(entity.id) ?? null;
+  }
+  const targetSchema = registry2.get(relation.target);
+  if (targetSchema) {
+    const nestedIncludes = (options.include ?? []).filter((inc) => inc.startsWith(`${relationName}.`)).map((inc) => inc.replace(`${relationName}.`, ""));
+    if (nestedIncludes.length > 0) {
+      await eagerLoadRelations(relatedEntities, targetSchema, db, registry2, {
+        ...options,
+        include: nestedIncludes
+      });
+    }
+  }
+}
+
+// src/schema/types.ts
+function isComputedField(field) {
+  return typeof field === "object" && field !== null && "_computed" in field && field._computed === true;
+}
+
+// src/runtime/resolver/view.ts
+function isEmbedDefinition(value) {
+  return typeof value === "object" && value !== null && "_embed" in value && value._embed === true;
+}
+var ViewResolver = class {
+  constructor(registry2, db) {
+    this.registry = registry2;
+    this.db = db;
+  }
+  /**
+   * Resolves a view schema with given parameters.
+   *
+   * @param view - The view schema to resolve
+   * @param params - URL parameters for the view
+   * @param context - Optional resolver context
+   * @returns The resolved view data
+   *
+   * @example
+   * ```typescript
+   * const userData = await viewResolver.resolve(UserFullView, { id: 'user-123' });
+   * ```
+   */
+  async resolve(view, params, context) {
+    clearComputeCache();
+    const resolverContext = {
+      mode: "resolve",
+      params,
+      ...context
+    };
+    return this.buildViewResult(view, { params, context: resolverContext });
+  }
+  /**
+   * Builds the view result by resolving all fields
+   */
+  async buildViewResult(view, options) {
+    const result = {};
+    for (const [fieldName, fieldDef] of Object.entries(view.fields)) {
+      if (isEmbedDefinition(fieldDef)) {
+        result[fieldName] = await this.resolveEmbed(fieldDef, result, options);
+      } else if (isComputedField(fieldDef)) {
+        result[fieldName] = await this.resolveViewComputedField(fieldDef, result, options);
+      } else if (this.isNestedObjectField(fieldDef)) {
+        result[fieldName] = await this.resolveNestedObject(fieldDef, result, options);
+      } else {
+        const paramValue = options.params[fieldName];
+        if (paramValue !== void 0) {
+          result[fieldName] = paramValue;
+        }
+      }
+    }
+    return result;
+  }
+  /**
+   * Check if a field definition is a nested object
+   */
+  isNestedObjectField(fieldDef) {
+    return typeof fieldDef === "object" && fieldDef !== null && !("type" in fieldDef) && !("_computed" in fieldDef) && !("_embed" in fieldDef);
+  }
+  /**
+   * Resolves an embedded entity field
+   */
+  async resolveEmbed(embed, parentData, options) {
+    const targetDb = this.db[embed.entity.name];
+    if (!targetDb) {
+      throw new Error(`Target entity '${embed.entity.name}' not found in database`);
+    }
+    const query = { where: {} };
+    const idParam = options.params.id;
+    if (idParam) {
+      const possibleForeignKeys = [
+        `${this.guessParentEntityName(options)}Id`,
+        "userId",
+        "authorId",
+        "parentId"
+      ];
+      for (const fk of possibleForeignKeys) {
+        if (embed.entity.fields && fk in embed.entity.fields) {
+          query.where[fk] = { equals: idParam };
+          break;
+        }
+      }
+    }
+    if (embed.config?.limit) {
+      query.take = embed.config.limit;
+    }
+    if (embed.config?.orderBy) {
+      query.orderBy = embed.config.orderBy;
+    }
+    const shouldReturnArray = !embed.config?.limit || embed.config.limit > 1;
+    if (shouldReturnArray) {
+      const results = targetDb.findMany(query);
+      return results;
+    } else {
+      const result = targetDb.findFirst(query);
+      return result;
+    }
+  }
+  /**
+   * Guess the parent entity name from the view endpoint
+   */
+  guessParentEntityName(options) {
+    return "user";
+  }
+  /**
+   * Resolves a computed field within a view context
+   */
+  async resolveViewComputedField(computed, currentData, options) {
+    if (options.context.mode === "seed" && computed.mock) {
+      return computed.mock();
+    }
+    return computed.resolve(currentData, this.db, options.context);
+  }
+  /**
+   * Resolves a nested object containing fields and computed values
+   */
+  async resolveNestedObject(nestedDef, parentData, options) {
+    const result = {};
+    for (const [fieldName, fieldDef] of Object.entries(nestedDef)) {
+      if (isComputedField(fieldDef)) {
+        result[fieldName] = await this.resolveViewComputedField(fieldDef, parentData, options);
+      } else {
+        result[fieldName] = fieldDef;
+      }
+    }
+    return result;
+  }
+  /**
+   * Resolves a view with mock data (for seeding)
+   */
+  async resolveMock(view, params) {
+    return this.resolve(view, params, { mode: "seed" });
+  }
+};
+function createViewResolver(registry2, db) {
+  return new ViewResolver(registry2, db);
+}
+
+// src/runtime/resolver/resolver.ts
+var Resolver = class _Resolver {
+  constructor(registry2, db, context) {
+    this.registry = registry2;
+    this.db = db;
+    this.context = { mode: "resolve", ...context };
+    this.viewResolver = new ViewResolver(registry2, db);
+  }
+  context;
+  viewResolver;
+  /**
+   * Find a single entity by ID
+   *
+   * @param entityName - The entity type to find
+   * @param id - The entity ID
+   * @param options - Query options (relations, computed fields)
+   * @returns The entity or null if not found
+   *
+   * @example
+   * ```typescript
+   * const user = await resolver.findOne('user', '123', {
+   *   include: ['profile'],
+   *   computed: ['postCount'],
+   * });
+   * ```
+   */
+  async findOne(entityName, id, options = {}) {
+    clearComputeCache();
+    const schema = this.registry.getOrThrow(entityName);
+    const entityDb = this.db[entityName];
+    if (!entityDb) {
+      throw new Error(`Entity '${entityName}' not found in database`);
+    }
+    const entity = entityDb.findFirst({
+      where: { id: { equals: id } }
+    });
+    if (!entity) return null;
+    await resolveRelations(entity, schema, this.db, this.registry, options);
+    await resolveComputedFields(entity, schema, this.db, this.context);
+    return entity;
+  }
+  /**
+   * Find multiple entities with filtering and pagination
+   *
+   * @param entityName - The entity type to find
+   * @param options - Query options (filters, pagination, relations)
+   * @returns Array of entities
+   *
+   * @example
+   * ```typescript
+   * const users = await resolver.findMany('user', {
+   *   where: { role: 'admin' },
+   *   limit: 20,
+   *   offset: 0,
+   *   include: ['profile'],
+   * });
+   * ```
+   */
+  async findMany(entityName, options = {}) {
+    clearComputeCache();
+    const schema = this.registry.getOrThrow(entityName);
+    const entityDb = this.db[entityName];
+    if (!entityDb) {
+      throw new Error(`Entity '${entityName}' not found in database`);
+    }
+    const query = {};
+    if (options.where) {
+      query.where = this.buildWhereClause(options.where);
+    }
+    if (options.limit) {
+      query.take = options.limit;
+    }
+    if (options.offset) {
+      query.skip = options.offset;
+    }
+    if (options.orderBy) {
+      query.orderBy = options.orderBy;
+    }
+    const entities = entityDb.findMany(query);
+    await eagerLoadRelations(entities, schema, this.db, this.registry, options);
+    for (const entity of entities) {
+      await resolveComputedFields(entity, schema, this.db, this.context);
+    }
+    return entities;
+  }
+  /**
+   * Create a new entity
+   *
+   * @param entityName - The entity type to create
+   * @param data - The entity data
+   * @param options - Query options for the returned entity
+   * @returns The created entity with relations and computed fields
+   *
+   * @example
+   * ```typescript
+   * const user = await resolver.create('user', {
+   *   name: 'John Doe',
+   *   email: 'john@example.com',
+   * });
+   * ```
+   */
+  async create(entityName, data, options = {}) {
+    const schema = this.registry.getOrThrow(entityName);
+    const entityDb = this.db[entityName];
+    if (!entityDb) {
+      throw new Error(`Entity '${entityName}' not found in database`);
+    }
+    if (!entityDb.create) {
+      throw new Error(`Entity '${entityName}' does not support create operation`);
+    }
+    const entity = entityDb.create(data);
+    await resolveRelations(entity, schema, this.db, this.registry, options);
+    await resolveComputedFields(entity, schema, this.db, this.context);
+    return entity;
+  }
+  /**
+   * Update an existing entity
+   *
+   * @param entityName - The entity type to update
+   * @param id - The entity ID
+   * @param data - The update data
+   * @param options - Query options for the returned entity
+   * @returns The updated entity or null if not found
+   *
+   * @example
+   * ```typescript
+   * const user = await resolver.update('user', '123', {
+   *   name: 'Jane Doe',
+   * });
+   * ```
+   */
+  async update(entityName, id, data, options = {}) {
+    const schema = this.registry.getOrThrow(entityName);
+    const entityDb = this.db[entityName];
+    if (!entityDb) {
+      throw new Error(`Entity '${entityName}' not found in database`);
+    }
+    if (!entityDb.update) {
+      throw new Error(`Entity '${entityName}' does not support update operation`);
+    }
+    const entity = entityDb.update({
+      where: { id: { equals: id } },
+      data
+    });
+    if (!entity) return null;
+    await resolveRelations(entity, schema, this.db, this.registry, options);
+    await resolveComputedFields(entity, schema, this.db, this.context);
+    return entity;
+  }
+  /**
+   * Delete an entity by ID
+   *
+   * @param entityName - The entity type to delete
+   * @param id - The entity ID
+   * @returns true if deleted, false if not found
+   *
+   * @example
+   * ```typescript
+   * const deleted = await resolver.delete('user', '123');
+   * ```
+   */
+  delete(entityName, id) {
+    const entityDb = this.db[entityName];
+    if (!entityDb) {
+      throw new Error(`Entity '${entityName}' not found in database`);
+    }
+    if (!entityDb.delete) {
+      throw new Error(`Entity '${entityName}' does not support delete operation`);
+    }
+    const deleted = entityDb.delete({
+      where: { id: { equals: id } }
+    });
+    return deleted !== null;
+  }
+  /**
+   * Count entities matching a filter
+   *
+   * @param entityName - The entity type to count
+   * @param options - Count options (filters)
+   * @returns The count
+   *
+   * @example
+   * ```typescript
+   * const adminCount = await resolver.count('user', {
+   *   where: { role: 'admin' },
+   * });
+   * ```
+   */
+  count(entityName, options = {}) {
+    const entityDb = this.db[entityName];
+    if (!entityDb) {
+      throw new Error(`Entity '${entityName}' not found in database`);
+    }
+    const query = options.where ? { where: this.buildWhereClause(options.where) } : {};
+    return entityDb.count(query);
+  }
+  /**
+   * Resolve a view with parameters
+   *
+   * @param viewName - The view name
+   * @param params - View parameters
+   * @returns The resolved view data
+   *
+   * @example
+   * ```typescript
+   * const userFull = await resolver.view('user-full', { id: '123' });
+   * ```
+   */
+  async view(viewName, params) {
+    clearComputeCache();
+    const viewSchema = this.registry.getViewOrThrow(viewName);
+    return this.viewResolver.resolve(viewSchema, params, this.context);
+  }
+  /**
+   * Build a where clause from simple object to database format
+   */
+  buildWhereClause(where) {
+    const clause = {};
+    for (const [key, value] of Object.entries(where)) {
+      if (typeof value === "object" && value !== null && !Array.isArray(value)) {
+        clause[key] = value;
+      } else if (Array.isArray(value)) {
+        clause[key] = { in: value };
+      } else {
+        clause[key] = { equals: value };
+      }
+    }
+    return clause;
+  }
+  /**
+   * Get the current resolver context
+   */
+  getContext() {
+    return { ...this.context };
+  }
+  /**
+   * Create a new resolver with updated context
+   */
+  withContext(context) {
+    return new _Resolver(this.registry, this.db, { ...this.context, ...context });
+  }
+};
+function createResolver(registry2, db, context) {
+  return new Resolver(registry2, db, context);
+}
+
+// src/runtime/setup.ts
+var state = {
+  initialized: false,
+  adapter: null,
+  schemas: [],
+  worker: null,
+  server: null
+};
+async function setup(options) {
+  if (state.initialized) {
+    console.warn("Schemock runtime already initialized");
+    return;
+  }
+  if (options) {
+    state.adapter = options.adapter;
+    state.schemas = options.schemas;
+  }
+  if (options?.startMsw && typeof window !== "undefined" && options.schemas.length > 0) {
+    await startMswWorker(options);
+  }
+  state.initialized = true;
+}
+async function startMswWorker(options) {
+  try {
+    const { setupWorker } = await import('msw/browser');
+    const { createHandlers: createHandlers2 } = await Promise.resolve().then(() => (init_handlers(), handlers_exports));
+    const handlers = createHandlers2(
+      options.schemas,
+      state.adapter,
+      options.mswOptions
+    );
+    state.worker = setupWorker(...handlers);
+    await state.worker.start({
+      quiet: options.mswOptions?.quiet ?? true
+    });
+  } catch (error) {
+    console.warn("MSW setup failed:", error);
+  }
+}
+async function teardown() {
+  if (state.worker) {
+    await state.worker.stop();
+    state.worker = null;
+  }
+  state.adapter = null;
+  state.schemas = [];
+  state.initialized = false;
+}
+function isInitialized() {
+  return state.initialized;
+}
+function getAdapter() {
+  return state.adapter;
+}
+function setAdapter(adapter) {
+  state.adapter = adapter;
+}
+
+// src/runtime/seed.ts
+function seed(counts) {
+  const adapter = getAdapter();
+  if (!adapter) {
+    throw new Error(
+      "No adapter configured. Call setup() first or use adapter.seed() directly."
+    );
+  }
+  if (adapter.name !== "mock") {
+    throw new Error(
+      `seed() only works with MockAdapter. Current adapter: ${adapter.name}`
+    );
+  }
+  adapter.seed(counts);
+}
+function reset() {
+  const adapter = getAdapter();
+  if (!adapter) {
+    throw new Error("No adapter configured. Call setup() first.");
+  }
+  if (adapter.name !== "mock") {
+    throw new Error(
+      `reset() only works with MockAdapter. Current adapter: ${adapter.name}`
+    );
+  }
+  adapter.reset();
+}
+function seedWithRelations(counts, relations) {
+  const adapter = getAdapter();
+  if (!adapter || adapter.name !== "mock") {
+    throw new Error("seedWithRelations() requires MockAdapter");
+  }
+  const deps = /* @__PURE__ */ new Map();
+  for (const entity of Object.keys(counts)) {
+    deps.set(entity, /* @__PURE__ */ new Set());
+  }
+  for (const [entity, fks] of Object.entries(relations)) {
+    for (const targetEntity of Object.values(fks)) {
+      deps.get(entity)?.add(targetEntity);
+    }
+  }
+  const sorted = [];
+  const visited = /* @__PURE__ */ new Set();
+  const visiting = /* @__PURE__ */ new Set();
+  function visit(entity) {
+    if (visited.has(entity)) return;
+    if (visiting.has(entity)) {
+      throw new Error(`Circular dependency detected: ${entity}`);
+    }
+    visiting.add(entity);
+    for (const dep of deps.get(entity) || []) {
+      visit(dep);
+    }
+    visiting.delete(entity);
+    visited.add(entity);
+    sorted.push(entity);
+  }
+  for (const entity of Object.keys(counts)) {
+    visit(entity);
+  }
+  const entityIds = {};
+  for (const entity of sorted) {
+    const count = counts[entity];
+    if (count === void 0) continue;
+    const fks = relations[entity] || {};
+    const parentIds = {};
+    for (const [fkField, parentEntity] of Object.entries(fks)) {
+      parentIds[fkField] = entityIds[parentEntity] || [];
+    }
+    entityIds[entity] = [];
+    for (let i = 0; i < count; i++) {
+      const data = {};
+      for (const [fkField, ids] of Object.entries(parentIds)) {
+        if (ids.length > 0) {
+          data[fkField] = ids[Math.floor(Math.random() * ids.length)];
+        }
+      }
+      const result = adapter.create({
+        entity,
+        data
+      });
+      result.then((res) => {
+        if (res.data?.id) {
+          entityIds[entity].push(res.data.id);
+        }
+      });
+    }
+  }
+}
+
+// src/runtime/index.ts
+init_handlers();
+
+exports.Resolver = Resolver;
+exports.SchemaRegistry = SchemaRegistry;
+exports.ViewResolver = ViewResolver;
+exports.clearComputeCache = clearComputeCache;
+exports.createHandlers = createHandlers;
+exports.createResolver = createResolver;
+exports.createViewResolver = createViewResolver;
+exports.eagerLoadRelations = eagerLoadRelations;
+exports.getAdapter = getAdapter;
+exports.isInitialized = isInitialized;
+exports.registry = registry;
+exports.reset = reset;
+exports.resolveComputedField = resolveComputedField;
+exports.resolveComputedFields = resolveComputedFields;
+exports.resolveComputedFieldsSync = resolveComputedFieldsSync;
+exports.resolveRelation = resolveRelation;
+exports.resolveRelations = resolveRelations;
+exports.seed = seed;
+exports.seedWithRelations = seedWithRelations;
+exports.setAdapter = setAdapter;
+exports.setup = setup;
+exports.teardown = teardown;
+exports.topologicalSort = topologicalSort;
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map