@rangka/core 0.0.1

package/src/model-api/__tests__/query-builder.test.ts

@@ -0,0 +1,224 @@
+import { describe, it, expect } from 'vitest';
+import {
+  Kysely,
+  DummyDriver,
+  PostgresAdapter,
+  PostgresIntrospector,
+  PostgresQueryCompiler,
+} from 'kysely';
+import { ModelQueryBuilder } from '../query-builder.js';
+import type { SchemaRegistry } from '../../schema/registry.js';
+import type { ResolvedModel } from '../../schema/types.js';
+import { KyselyModelOps } from '../../db/model-ops.js';
+
+function createTestDb(): Kysely<any> {
+  return new Kysely<any>({
+    dialect: {
+      createAdapter: () => new PostgresAdapter(),
+      createDriver: () => new DummyDriver(),
+      createIntrospector: (db: any) => new PostgresIntrospector(db),
+      createQueryCompiler: () => new PostgresQueryCompiler(),
+    },
+  });
+}
+
+function makeModel(qualifiedName: string, traits: string[] = []): ResolvedModel {
+  return {
+    qualifiedName,
+    app: 'test',
+    module: qualifiedName.split('.')[0],
+    name: qualifiedName.split('.')[1],
+    auditLog: false,
+    traits,
+    fields: [
+      { name: 'id', config: { type: 'uuid' }, provenance: { source: 'base' } },
+      { name: 'name', config: { type: 'string' }, provenance: { source: 'base' } },
+      { name: 'status', config: { type: 'string' }, provenance: { source: 'base' } },
+      { name: 'total', config: { type: 'money' }, provenance: { source: 'base' } },
+      {
+        name: 'created_at',
+        config: { type: 'datetime' },
+        provenance: { source: 'trait', trait: 'timestamped' },
+      },
+    ],
+    indexes: [],
+  } as ResolvedModel;
+}
+
+function makeRegistry(models: ResolvedModel[]): SchemaRegistry {
+  return {
+    getModel: (qn: string) => models.find((m) => m.qualifiedName === qn),
+    getAllModels: () => models,
+    getRelationshipsForModel: () => [],
+    getFieldsForModel: (qn: string) => models.find((m) => m.qualifiedName === qn)?.fields ?? [],
+  } as unknown as SchemaRegistry;
+}
+
+describe('ModelQueryBuilder', () => {
+  const db = createTestDb();
+  const model = makeModel('sales.Order');
+  const registry = makeRegistry([model]);
+  const ops = new KyselyModelOps({ db, model, registry });
+
+  function createBuilder() {
+    return new ModelQueryBuilder(ops, model, registry);
+  }
+
+  describe('compilation', () => {
+    it('generates basic select all from table', () => {
+      const builder = createBuilder();
+      const compiled = builder.compile() as { sql: string; parameters: unknown[] };
+      expect(compiled.sql).toContain('select * from "sales"."Order"');
+    });
+
+    it('applies filter', () => {
+      const builder = createBuilder().filter({ status: 'active' });
+      const compiled = builder.compile() as { sql: string; parameters: unknown[] };
+      expect(compiled.sql).toContain('"status" = $1');
+      expect(compiled.parameters).toContain('active');
+    });
+
+    it('applies multiple filters (chained)', () => {
+      const builder = createBuilder()
+        .filter({ status: 'active' })
+        .filter({ total: { gt: 100 } });
+      const compiled = builder.compile() as { sql: string; parameters: unknown[] };
+      expect(compiled.sql).toContain('"status" = $1');
+      expect(compiled.sql).toContain('"total" > $2');
+    });
+
+    it('applies sort ascending by default', () => {
+      const builder = createBuilder().sort('name');
+      const compiled = builder.compile() as { sql: string; parameters: unknown[] };
+      expect(compiled.sql).toContain('order by "name" asc');
+    });
+
+    it('applies sort descending', () => {
+      const builder = createBuilder().sort('created_at', 'desc');
+      const compiled = builder.compile() as { sql: string; parameters: unknown[] };
+      expect(compiled.sql).toContain('order by "created_at" desc');
+    });
+
+    it('applies multiple sorts in order', () => {
+      const builder = createBuilder().sort('status', 'asc').sort('created_at', 'desc');
+      const compiled = builder.compile() as { sql: string; parameters: unknown[] };
+      expect(compiled.sql).toContain('order by "status" asc, "created_at" desc');
+    });
+
+    it('applies limit', () => {
+      const builder = createBuilder().limit(10);
+      const compiled = builder.compile() as { sql: string; parameters: unknown[] };
+      expect(compiled.sql).toContain('limit $1');
+      expect(compiled.parameters).toContain(10);
+    });
+
+    it('applies offset', () => {
+      const builder = createBuilder().offset(20);
+      const compiled = builder.compile() as { sql: string; parameters: unknown[] };
+      expect(compiled.sql).toContain('offset $1');
+      expect(compiled.parameters).toContain(20);
+    });
+
+    it('applies limit and offset together', () => {
+      const builder = createBuilder().limit(10).offset(20);
+      const compiled = builder.compile() as { sql: string; parameters: unknown[] };
+      expect(compiled.sql).toContain('limit $1');
+      expect(compiled.sql).toContain('offset $2');
+    });
+
+    it('applies field selection', () => {
+      const builder = createBuilder().fields(['id', 'name', 'status']);
+      const compiled = builder.compile() as { sql: string; parameters: unknown[] };
+      expect(compiled.sql).toContain('"id"');
+      expect(compiled.sql).toContain('"name"');
+      expect(compiled.sql).toContain('"status"');
+      expect(compiled.sql).not.toContain('*');
+    });
+  });
+
+  describe('chaining order independence', () => {
+    it('produces same SQL regardless of method order', () => {
+      const a = createBuilder()
+        .filter({ status: 'active' })
+        .sort('name')
+        .limit(10)
+        .offset(5)
+        .compile() as { sql: string };
+
+      const b = createBuilder()
+        .limit(10)
+        .offset(5)
+        .sort('name')
+        .filter({ status: 'active' })
+        .compile() as { sql: string };
+
+      expect(a.sql).toBe(b.sql);
+    });
+  });
+
+  describe('count compilation', () => {
+    it('generates count query', () => {
+      const builder = createBuilder().filter({ status: 'active' });
+      const compiled = builder.compileCount() as { sql: string; parameters: unknown[] };
+      expect(compiled.sql).toContain('count(*)');
+      expect(compiled.sql).toContain('"status" = $1');
+      expect(compiled.sql).not.toContain('limit');
+      expect(compiled.sql).not.toContain('offset');
+      expect(compiled.sql).not.toContain('order by');
+    });
+  });
+
+  describe('immutability', () => {
+    it('each chain call returns a new instance', () => {
+      const base = createBuilder();
+      const filtered = base.filter({ status: 'active' });
+      const sorted = base.sort('name');
+
+      expect(filtered).not.toBe(base);
+      expect(sorted).not.toBe(base);
+      expect(filtered).not.toBe(sorted);
+
+      const filteredSql = (filtered.compile() as { sql: string }).sql;
+      const sortedSql = (sorted.compile() as { sql: string }).sql;
+      expect(filteredSql).toContain('"status"');
+      expect(filteredSql).not.toContain('order by');
+      expect(sortedSql).toContain('order by');
+      expect(sortedSql).not.toContain('"status"');
+    });
+  });
+
+  describe('unscoped', () => {
+    it('sets unscoped flag', () => {
+      const builder = createBuilder().unscoped();
+      expect(builder.isUnscoped()).toBe(true);
+    });
+
+    it('defaults to scoped', () => {
+      const builder = createBuilder();
+      expect(builder.isUnscoped()).toBe(false);
+    });
+  });
+
+  describe('include', () => {
+    it('stores include relations', () => {
+      const builder = createBuilder().include('customer').include('lineItems');
+      expect(builder.getIncludes()).toEqual(['customer', 'lineItems']);
+    });
+
+    it('deduplicates includes', () => {
+      const builder = createBuilder().include('customer').include('customer');
+      expect(builder.getIncludes()).toEqual(['customer']);
+    });
+  });
+
+  describe('soft_delete model', () => {
+    it('adds archived_at IS NULL filter by default', () => {
+      const softModel = makeModel('sales.Order', ['soft_delete']);
+      const softRegistry = makeRegistry([softModel]);
+      const softOps = new KyselyModelOps({ db, model: softModel, registry: softRegistry });
+      const builder = new ModelQueryBuilder(softOps, softModel, softRegistry);
+      const compiled = builder.compile() as { sql: string };
+      expect(compiled.sql).toContain('"archived_at" is null');
+    });
+  });
+});

package/src/model-api/__tests__/scope-enforcer.test.ts

@@ -0,0 +1,268 @@
+import { describe, it, expect } from 'vitest';
+import {
+  Kysely,
+  DummyDriver,
+  PostgresAdapter,
+  PostgresIntrospector,
+  PostgresQueryCompiler,
+} from 'kysely';
+import { applyScopeEnforcement, stripHiddenFields, enforceReadOnly } from '../scope-enforcer.js';
+import type { ResolvedModel } from '../../schema/types.js';
+import type { RequestContext, ScopeFilter } from '../../auth/types.js';
+
+function createTestDb() {
+  return new Kysely<any>({
+    dialect: {
+      createAdapter: () => new PostgresAdapter(),
+      createDriver: () => new DummyDriver(),
+      createIntrospector: (db: any) => new PostgresIntrospector(db),
+      createQueryCompiler: () => new PostgresQueryCompiler(),
+    },
+  });
+}
+
+function makeModel(qualifiedName: string, traits: string[] = []): ResolvedModel {
+  return {
+    qualifiedName,
+    app: 'test',
+    module: qualifiedName.split('.')[0],
+    name: qualifiedName.split('.')[1],
+    auditLog: false,
+    traits,
+    fields: [
+      { name: 'id', config: { type: 'uuid' }, provenance: { source: 'base' } },
+      { name: 'name', config: { type: 'string' }, provenance: { source: 'base' } },
+      { name: 'secret_field', config: { type: 'string' }, provenance: { source: 'base' } },
+      { name: 'tenant_id', config: { type: 'uuid' }, provenance: { source: 'base' } },
+      {
+        name: 'created_by',
+        config: { type: 'uuid' },
+        provenance: { source: 'trait', trait: 'timestamped' },
+      },
+    ],
+    indexes: [],
+  } as ResolvedModel;
+}
+
+describe('applyScopeEnforcement', () => {
+  const db = createTestDb();
+
+  it('adds scope filter WHERE clauses to query', () => {
+    const scopeFilters: ScopeFilter[] = [{ field: 'tenant_id', operator: 'eq', value: 'tenant-1' }];
+    const auth: RequestContext = { scopeFilters };
+
+    let query = db.selectFrom('sales__Order').selectAll();
+    query = applyScopeEnforcement(query, auth);
+    const compiled = query.compile();
+
+    expect(compiled.sql).toContain('"tenant_id" = $1');
+    expect(compiled.parameters).toEqual(['tenant-1']);
+  });
+
+  it('adds multiple scope filters as AND conditions', () => {
+    const scopeFilters: ScopeFilter[] = [
+      { field: 'tenant_id', operator: 'eq', value: 'tenant-1' },
+      { field: 'branch_id', operator: 'eq', value: 'branch-1' },
+    ];
+    const auth: RequestContext = { scopeFilters };
+
+    let query = db.selectFrom('sales__Order').selectAll();
+    query = applyScopeEnforcement(query, auth);
+    const compiled = query.compile();
+
+    expect(compiled.sql).toContain('"tenant_id" = $1');
+    expect(compiled.sql).toContain('"branch_id" = $2');
+    expect(compiled.parameters).toEqual(['tenant-1', 'branch-1']);
+  });
+
+  it('handles "in" operator for scope filters', () => {
+    const scopeFilters: ScopeFilter[] = [
+      { field: 'tenant_id', operator: 'in', value: ['t-1', 't-2'] },
+    ];
+    const auth: RequestContext = { scopeFilters };
+
+    let query = db.selectFrom('sales__Order').selectAll();
+    query = applyScopeEnforcement(query, auth);
+    const compiled = query.compile();
+
+    expect(compiled.sql).toContain('"tenant_id" in ($1, $2)');
+    expect(compiled.parameters).toEqual(['t-1', 't-2']);
+  });
+
+  it('does nothing when no scope filters exist', () => {
+    const auth: RequestContext = {};
+
+    let query = db.selectFrom('sales__Order').selectAll();
+    query = applyScopeEnforcement(query, auth);
+    const compiled = query.compile();
+
+    expect(compiled.sql).not.toContain('where');
+  });
+
+  it('does nothing when scopeFilters is empty array', () => {
+    const auth: RequestContext = { scopeFilters: [] };
+
+    let query = db.selectFrom('sales__Order').selectAll();
+    query = applyScopeEnforcement(query, auth);
+    const compiled = query.compile();
+
+    expect(compiled.sql).not.toContain('where');
+  });
+
+  it('does nothing when auth is undefined', () => {
+    let query = db.selectFrom('sales__Order').selectAll();
+    query = applyScopeEnforcement(query, undefined);
+    const compiled = query.compile();
+
+    expect(compiled.sql).not.toContain('where');
+  });
+
+  it('adds owner-only filter when specified', () => {
+    const auth: RequestContext = {
+      user: { id: 'user-1', email: 'a@b.c', full_name: 'A', enabled: true, password_hash: '' },
+      permissions: {
+        models: {
+          'sales.Order': { read: 'own', write: 'own', delete: 'own' },
+        },
+        pages: [],
+        version: 1,
+      },
+    };
+
+    const model = makeModel('sales.Order');
+    let query = db.selectFrom('sales__Order').selectAll();
+    query = applyScopeEnforcement(query, auth, { model, checkOwnership: true });
+    const compiled = query.compile();
+
+    expect(compiled.sql).toContain('"created_by" = $1');
+    expect(compiled.parameters).toEqual(['user-1']);
+  });
+
+  it('does not add owner filter when permission is not "own"', () => {
+    const auth: RequestContext = {
+      user: { id: 'user-1', email: 'a@b.c', full_name: 'A', enabled: true, password_hash: '' },
+      permissions: {
+        models: {
+          'sales.Order': { read: true, write: true, delete: true },
+        },
+        pages: [],
+        version: 1,
+      },
+    };
+
+    const model = makeModel('sales.Order');
+    let query = db.selectFrom('sales__Order').selectAll();
+    query = applyScopeEnforcement(query, auth, { model, checkOwnership: true });
+    const compiled = query.compile();
+
+    expect(compiled.sql).not.toContain('"created_by"');
+  });
+
+  it('does not add owner filter when model lacks created_by field', () => {
+    const auth: RequestContext = {
+      user: { id: 'user-1', email: 'a@b.c', full_name: 'A', enabled: true, password_hash: '' },
+      permissions: {
+        models: {
+          'sales.Order': { read: 'own', write: 'own', delete: 'own' },
+        },
+        pages: [],
+        version: 1,
+      },
+    };
+
+    const modelWithoutCreatedBy = {
+      qualifiedName: 'sales.Order',
+      app: 'test',
+      module: 'sales',
+      name: 'Order',
+      auditLog: false,
+      traits: [],
+      fields: [{ name: 'id', config: { type: 'string' }, provenance: { source: 'base' } }],
+      indexes: [],
+    } as ResolvedModel;
+
+    let query = db.selectFrom('sales__Order').selectAll();
+    query = applyScopeEnforcement(query, auth, {
+      model: modelWithoutCreatedBy,
+      checkOwnership: true,
+    });
+    const compiled = query.compile();
+
+    expect(compiled.sql).not.toContain('"created_by"');
+  });
+});
+
+describe('stripHiddenFields', () => {
+  it('removes hidden fields from a single record', () => {
+    const record = { id: '1', name: 'Test', secret_field: 'secret' };
+    const hidden = new Set(['secret_field']);
+    const result = stripHiddenFields(record, hidden);
+    expect(result).toEqual({ id: '1', name: 'Test' });
+  });
+
+  it('removes hidden fields from array of records', () => {
+    const records = [
+      { id: '1', name: 'A', secret_field: 'x' },
+      { id: '2', name: 'B', secret_field: 'y' },
+    ];
+    const hidden = new Set(['secret_field']);
+    const result = records.map((r) => stripHiddenFields(r, hidden));
+    expect(result).toEqual([
+      { id: '1', name: 'A' },
+      { id: '2', name: 'B' },
+    ]);
+  });
+
+  it('returns record unchanged when no fields are hidden', () => {
+    const record = { id: '1', name: 'Test' };
+    const hidden = new Set<string>();
+    const result = stripHiddenFields(record, hidden);
+    expect(result).toEqual(record);
+  });
+
+  it('returns empty object when all fields are hidden', () => {
+    const record = { id: '1', name: 'Test' };
+    const hidden = new Set(['id', 'name']);
+    const result = stripHiddenFields(record, hidden);
+    expect(result).toEqual({});
+  });
+
+  it('handles record with nested objects (does not strip nested)', () => {
+    const record = { id: '1', meta: { secret_field: 'x' }, secret_field: 'top' };
+    const hidden = new Set(['secret_field']);
+    const result = stripHiddenFields(record, hidden);
+    expect(result).toEqual({ id: '1', meta: { secret_field: 'x' } });
+  });
+});
+
+describe('enforceReadOnly', () => {
+  it('throws when writing to a read-only field', () => {
+    const readOnly = new Set(['status']);
+    const data = { status: 'active', name: 'Test' };
+    expect(() => enforceReadOnly(data, readOnly)).toThrow(/read-only.*status/i);
+  });
+
+  it('does not throw when writing to non-read-only fields', () => {
+    const readOnly = new Set(['status']);
+    const data = { name: 'Test', email: 'a@b.c' };
+    expect(() => enforceReadOnly(data, readOnly)).not.toThrow();
+  });
+
+  it('does not throw when readOnly set is empty', () => {
+    const readOnly = new Set<string>();
+    const data = { status: 'active', name: 'Test' };
+    expect(() => enforceReadOnly(data, readOnly)).not.toThrow();
+  });
+
+  it('reports all violated fields in the error', () => {
+    const readOnly = new Set(['status', 'level']);
+    const data = { status: 'active', level: 5, name: 'Test' };
+    expect(() => enforceReadOnly(data, readOnly)).toThrow(/status.*level|level.*status/);
+  });
+
+  it('ignores undefined values (not actually writing)', () => {
+    const readOnly = new Set(['status']);
+    const data = { status: undefined, name: 'Test' };
+    expect(() => enforceReadOnly(data, readOnly)).not.toThrow();
+  });
+});

package/src/model-api/field-access.ts

@@ -0,0 +1,28 @@
+export function stripHiddenFields(
+  record: Record<string, unknown>,
+  hidden: Set<string>,
+): Record<string, unknown> {
+  if (hidden.size === 0) return record;
+  const result: Record<string, unknown> = {};
+  for (const [key, value] of Object.entries(record)) {
+    if (!hidden.has(key)) {
+      result[key] = value;
+    }
+  }
+  return result;
+}
+
+export function enforceReadOnly(data: Record<string, unknown>, readOnly: Set<string>): void {
+  if (readOnly.size === 0) return;
+
+  const violated: string[] = [];
+  for (const field of readOnly) {
+    if (field in data && data[field] !== undefined) {
+      violated.push(field);
+    }
+  }
+
+  if (violated.length > 0) {
+    throw new Error(`Cannot write to read-only fields: ${violated.join(', ')}`);
+  }
+}

package/src/model-api/filter-applier.ts

@@ -0,0 +1 @@
+export { applyModelFilters } from '../db/filter-applier.js';

package/src/model-api/filter-translator.ts

@@ -0,0 +1,67 @@
+import type { FilterExpression, FilterOperators, TranslatedFilter } from './types.js';
+import { isNil } from '../helpers/coerce.js';
+
+export type { TranslatedFilter } from './types.js';
+
+const VALID_OPERATORS = new Set([
+  'eq',
+  'neq',
+  'gt',
+  'gte',
+  'lt',
+  'lte',
+  'in',
+  'notIn',
+  'contains',
+  'startsWith',
+  'endsWith',
+  'is',
+]);
+
+function isOperatorObject(value: unknown): value is FilterOperators {
+  if (isNil(value)) return false;
+  if (typeof value !== 'object') return false;
+  if (Array.isArray(value)) return false;
+  if (value instanceof Date) return false;
+  const keys = Object.keys(value);
+  if (keys.length === 0) return false;
+  const hasAnyKnown = keys.some((k) => VALID_OPERATORS.has(k));
+  const hasAnyUnknown = keys.some((k) => !VALID_OPERATORS.has(k));
+  if (hasAnyUnknown && !hasAnyKnown) {
+    throw new Error(`Unknown filter operator: ${keys.find((k) => !VALID_OPERATORS.has(k))}`);
+  }
+  if (hasAnyUnknown && hasAnyKnown) {
+    throw new Error(`Unknown filter operator: ${keys.find((k) => !VALID_OPERATORS.has(k))}`);
+  }
+  return true;
+}
+
+export function translateFilters(
+  expression: FilterExpression | null | undefined,
+): TranslatedFilter[] {
+  if (!expression || typeof expression !== 'object') return [];
+
+  const results: TranslatedFilter[] = [];
+
+  for (const [field, value] of Object.entries(expression)) {
+    if (value === null) {
+      results.push({ field, operator: 'is', value: null });
+      continue;
+    }
+
+    if (isOperatorObject(value)) {
+      const ops = value as Record<string, unknown>;
+      for (const [op, opValue] of Object.entries(ops)) {
+        if (!VALID_OPERATORS.has(op)) {
+          throw new Error(`Unknown filter operator: ${op}`);
+        }
+        results.push({ field, operator: op, value: opValue });
+      }
+      continue;
+    }
+
+    results.push({ field, operator: 'eq', value });
+  }
+
+  return results;
+}

package/src/model-api/include-resolver.ts

@@ -0,0 +1,2 @@
+export { resolveModelIncludes } from '../db/model-include-resolver.js';
+export type { IncludeResolverOptions, IncludeSpec } from '../db/model-include-resolver.js';

package/src/model-api/index.ts

@@ -0,0 +1,86 @@
+import type { ModelAccess, ModelAccessOptions, ModelOps, ModelQuery } from './types.js';
+import { ModelQueryBuilder } from './query-builder.js';
+import { KyselyModelOps } from '../db/model-ops.js';
+import { ExternalModelOps } from '../external-model/external-model-ops.js';
+import { CompositeIncludeResolver } from '../db/include-resolver.js';
+
+export type {
+  ModelAccess,
+  ModelQuery,
+  ModelAccessOptions,
+  ModelOps,
+  FilterExpression,
+  QueryResult,
+  QueryResultWithMeta,
+  QueryState,
+  TranslatedFilter,
+  IncludeResolver,
+} from './types.js';
+export { ModelQueryBuilder } from './query-builder.js';
+export { translateFilters } from './filter-translator.js';
+export { applyModelFilters } from './filter-applier.js';
+export { applyScopeEnforcement, stripHiddenFields, enforceReadOnly } from './scope-enforcer.js';
+export { resolveModelIncludes } from './include-resolver.js';
+export { CapabilityNotSupportedError } from '../external-model/mutation-executor.js';
+
+export function createModelAccess(opts: ModelAccessOptions): ModelAccess {
+  const { db, registry, auth, adapterRegistry, externalModelFields, adapterCapabilities } = opts;
+
+  const includeResolver = new CompositeIncludeResolver({
+    registry,
+    db,
+    adapterRegistry,
+    externalModelFields,
+  });
+
+  function resolveOps(modelName: string): ModelOps {
+    const model = registry.getModel(modelName);
+    if (!model) throw new Error(`Model not found: ${modelName}`);
+
+    if (model.source) {
+      if (!adapterRegistry) {
+        throw new Error(
+          `No adapter registry configured. Cannot resolve external model: ${modelName}`,
+        );
+      }
+      const adapter = adapterRegistry.get(model.source);
+      const fields = externalModelFields?.[model.qualifiedName] ?? {};
+      const capabilities = adapterCapabilities?.[model.source] ?? ['read'];
+      return new ExternalModelOps({
+        adapter,
+        adapterName: model.source,
+        modelName: model.qualifiedName,
+        fields,
+        capabilities,
+      });
+    }
+
+    return new KyselyModelOps({ db, model, registry, auth });
+  }
+
+  return {
+    async get(modelName: string, id: string) {
+      return resolveOps(modelName).get(id);
+    },
+
+    query(modelName: string): ModelQuery {
+      const model = registry.getModel(modelName);
+      if (!model) throw new Error(`Model not found: ${modelName}`);
+      const ops = resolveOps(modelName);
+      const qb = new ModelQueryBuilder(ops, model, registry, includeResolver);
+      return auth ? qb.withAuth(auth) : qb;
+    },
+
+    async create(modelName: string, data: Record<string, unknown>) {
+      return resolveOps(modelName).create(data, auth);
+    },
+
+    async update(modelName: string, id: string, data: Record<string, unknown>) {
+      return resolveOps(modelName).update(id, data, auth);
+    },
+
+    async delete(modelName: string, id: string) {
+      return resolveOps(modelName).delete(id, auth);
+    },
+  };
+}