@rangka/core 0.1.0 → 0.1.2

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

@@ -1,224 +0,0 @@
-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

@@ -1,268 +0,0 @@
-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

@@ -1,28 +0,0 @@
-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

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

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

@@ -1,67 +0,0 @@
-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

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

package/src/model-api/index.ts

@@ -1,86 +0,0 @@
-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);
-    },
-  };
-}