@object-ui/data-objectstack 17.5.0 → 17.7.0

package/src/deleteViewContract.types.test.ts

@@ -1,246 +0,0 @@
-/**
- * ObjectUI
- * Copyright (c) 2024-present ObjectStack Inc.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-import { describe, it, expect, vi } from 'vitest';
-import type { DataSource, DeleteViewResult, ViewHomeDeleteOutcome } from '@object-ui/types';
-import {
-  ObjectStackAdapter,
-  type DeleteViewResult as AdapterDeleteViewResult,
-  type ViewHomeDeleteOutcome as AdapterViewHomeDeleteOutcome,
-} from './index';
-
-/**
- * The shared `DataSource` contract carries `deleteView`'s per-home outcomes
- * (#4564).
- *
- * #4479 / PR #4562 widened THIS adapter's `deleteView` to return
- * `DeleteViewResult { deleted, draft?, published? }`, but the shared interface
- * in `@object-ui/types` still declared the narrow `{ deleted: boolean }`. The
- * adapter's wider return is assignable to the narrower declaration, so nothing
- * failed to compile — which is exactly what made the gap invisible: a consumer
- * reaching the adapter THROUGH `DataSource` was handed a type that had already
- * thrown the per-home outcomes away. The one real call site today (app-shell's
- * `ObjectView` delete handler) reads nothing off the receipt, so the loss was
- * latent rather than broken.
- *
- * #4564's ruling moved the canonical shapes DOWN to `@object-ui/types` beside
- * the interface (the dependency runs data-objectstack -> types, so the shapes
- * could not be imported upward), widened `DataSource.deleteView?`'s declared
- * return to `DeleteViewResult`, and left this package re-exporting both names
- * so every existing importer keeps compiling.
- *
- * ## Where these pins get their colour
- *
- * Most of this file is COMPILE-time. That is not a weaker pin, it is the only
- * pin that can observe this defect: the bug was never a wrong value at runtime,
- * it was a declaration that could not describe the value. `vitest` transpiles
- * with esbuild and erases types, so the runtime case below passed just as
- * happily against the narrow declaration — its `receipt.draft` read was a
- * `tsc` error and a green test at the same time. The colour therefore comes
- * from `pnpm --filter @object-ui/data-objectstack type-check`, and this
- * package's `tsconfig.json` includes its whole `src/**` (tests included), so
- * these assertions are checked there and by CI's Type Check job with no
- * separate `tsconfig.typetests.json` — the same property `queryDataset.test.ts`
- * and `spec-symbol-batch6.test.ts` document and rely on.
- *
- * ## The discrimination control
- *
- * `NarrowLegacyResult` below is `deleteView`'s declared return BEFORE #4564,
- * kept as a live control rather than described in prose. Every "the contract
- * carries the per-home outcomes" assertion is paired with the control failing
- * to carry them. Undo the move and the paired assertions go red together,
- * which is what stops this file from degrading into a restatement of whatever
- * the interface happens to say.
- */
-
-const VIEW = 'account.my_pipeline';
-
-/** Framework receipt: a draft row existed and was discarded. */
-const DRAFT_DISCARDED = {
-  success: true,
-  reset: true,
-  seq: 41,
-  message: `Draft discarded — view/${VIEW}. [seq=41]`,
-};
-
-/** Framework receipt: no published row. A 200 carrying `reset:false`, not a 404. */
-const NO_PUBLISHED = {
-  success: true,
-  reset: false,
-  message: `No view '${VIEW}' found — nothing to delete.`,
-};
-
-/**
- * The smallest adapter that can answer both view-delete addresses.
- *
- * Deliberately NOT a second copy of `deleteView.homes.test.ts`'s harness: that
- * file owns the behaviour (15 pins over both homes, the ordering, the failure
- * paths) and stays untouched. This one exists only to drive one call through a
- * `DataSource`-typed handle, so the per-home read below is served by the shared
- * declaration and by nothing else.
- */
-function makeAdapter(): ObjectStackAdapter {
-  const baseUrl = 'http://test.local';
-  const json = (body: unknown) =>
-    new Response(JSON.stringify(body), {
-      status: 200,
-      headers: { 'Content-Type': 'application/json' },
-    });
-
-  const fetchImpl = vi.fn(async (input: RequestInfo | URL, init?: RequestInit) => {
-    const url = String(input);
-    if (url.includes('/meta/view/') && (init?.method ?? 'GET') === 'DELETE') {
-      return json(url.includes('state=draft') ? DRAFT_DISCARDED : NO_PUBLISHED);
-    }
-    return json({ success: true, data: { capabilities: {}, routes: {} } });
-  });
-
-  const adapter = new ObjectStackAdapter({ baseUrl, fetch: fetchImpl });
-  const poke = adapter as any;
-  poke.connected = true;
-  poke.connectionState = 'connected';
-  poke.metadataCache = {
-    get: async (_key: string, loader: () => Promise<any>) => loader(),
-    invalidate: () => undefined,
-    getCachedSync: () => undefined,
-    getStats: () => ({}),
-  };
-  return adapter;
-}
-
-/* -------------------------------------------------------------------------- */
-/* Compile-time vocabulary — the repo's idiom (queryDataset.test.ts).          */
-/* -------------------------------------------------------------------------- */
-
-type Assert<T extends true> = T;
-type Equal<A, B> = (<T>() => T extends A ? 1 : 2) extends <T>() => T extends B ? 1 : 2
-  ? true
-  : false;
-type HasKey<T, K extends PropertyKey> = K extends keyof T ? true : false;
-
-/** The shared contract's declared return, read off the interface itself. */
-type ContractDeleteView = NonNullable<DataSource['deleteView']>;
-type ContractReturn = Awaited<ReturnType<ContractDeleteView>>;
-
-/**
- * `DataSource.deleteView`'s declared return BEFORE #4564 — the control.
- * Kept as a type, not a comment, so "the contract used to lose the per-home
- * outcomes" is an assertion the compiler re-checks on every run.
- */
-interface NarrowLegacyResult {
-  deleted: boolean;
-}
-
-describe('DataSource.deleteView declares the per-home outcomes (#4564)', () => {
-  it('the shared contract returns the canonical DeleteViewResult, not a restatement', () => {
-    // `Equal` rather than a two-way `extends`: a structurally overlapping
-    // re-declaration in `types` would satisfy mutual assignability while
-    // drifting, and a hand copy is precisely what the one-resolver rule and
-    // this card's ruling rejected in favour of moving the declaration.
-    type _IsTheCanonicalShape = Assert<Equal<ContractReturn, DeleteViewResult>>;
-
-    expect(true).toBe(true);
-  });
-
-  it('carries `draft` and `published`, where the pre-#4564 declaration carried neither', () => {
-    type _CarriesDraft = Assert<Equal<HasKey<ContractReturn, 'draft'>, true>>;
-    type _CarriesPublished = Assert<Equal<HasKey<ContractReturn, 'published'>, true>>;
-
-    // The control, and the whole reason this file is a pin rather than an echo:
-    // the shape the interface used to declare cannot answer either read. If the
-    // move is reverted, the two assertions above go red and these two stay
-    // green — the difference between them IS #4564's delta.
-    type _ControlHasNoDraft = Assert<Equal<HasKey<NarrowLegacyResult, 'draft'>, false>>;
-    type _ControlHasNoPublished = Assert<Equal<HasKey<NarrowLegacyResult, 'published'>, false>>;
-    type _ContractIsNotTheNarrowShape = Assert<
-      Equal<Equal<ContractReturn, NarrowLegacyResult>, false>
-    >;
-
-    expect(true).toBe(true);
-  });
-
-  it('types the per-home outcomes as ViewHomeDeleteOutcome, optional on both homes', () => {
-    type _DraftIsTheOutcome = Assert<Equal<ContractReturn['draft'], ViewHomeDeleteOutcome | undefined>>;
-    type _PublishedIsTheOutcome = Assert<
-      Equal<ContractReturn['published'], ViewHomeDeleteOutcome | undefined>
-    >;
-    // `deleted` is unchanged — the growth is additive, so a consumer reading
-    // only `deleted` is untouched by the widening.
-    type _DeletedUnchanged = Assert<Equal<ContractReturn['deleted'], boolean>>;
-
-    expect(true).toBe(true);
-  });
-
-  it('MUST NOT CHANGE: deleteView stays OPTIONAL, with the same two parameters', () => {
-    // The widening is to the RETURN only. An adapter that never implemented
-    // `deleteView` must stay a legal `DataSource`.
-    type _StillOptional = Assert<undefined extends DataSource['deleteView'] ? true : false>;
-    type _SameParameters = Assert<Equal<Parameters<ContractDeleteView>, [string, string]>>;
-
-    expect(true).toBe(true);
-  });
-});
-
-describe('the data-objectstack spellings survive the move (#4564)', () => {
-  it('re-exports both names as the SAME declaration, not a structural twin', () => {
-    // The re-export contract: every importer that PR #4562 left pointing at
-    // `@object-ui/data-objectstack` keeps compiling, and keeps getting the type
-    // the shared interface now speaks. `Equal` is the assertion that matters —
-    // two identical-looking declarations are mutually assignable, so only
-    // identity can tell a re-export from a copy that will drift.
-    type _ResultIsTheTypesSpelling = Assert<Equal<AdapterDeleteViewResult, DeleteViewResult>>;
-    type _OutcomeIsTheTypesSpelling = Assert<
-      Equal<AdapterViewHomeDeleteOutcome, ViewHomeDeleteOutcome>
-    >;
-
-    expect(true).toBe(true);
-  });
-
-  it('the adapter method still satisfies the widened contract', () => {
-    const adapter = makeAdapter();
-
-    // Explicit, because `class ObjectStackAdapter implements DataSource` would
-    // have gone on compiling with the NARROW declaration too — a wider return
-    // is assignable to a narrower one, which is how the gap survived #4562's
-    // review in the first place. This states the direction the card cares
-    // about instead of inheriting it from the class heritage clause.
-    const deleteView = adapter.deleteView.bind(adapter) satisfies ContractDeleteView;
-    expect(typeof deleteView).toBe('function');
-
-    type _AdapterAssignableToContract = Assert<
-      ObjectStackAdapter['deleteView'] extends ContractDeleteView ? true : false
-    >;
-    // ...and no longer merely assignable: the two returns are now one type, so
-    // the adapter cannot widen further without the contract following it.
-    type _ReturnsAreOneType = Assert<
-      Equal<Awaited<ReturnType<ObjectStackAdapter['deleteView']>>, ContractReturn>
-    >;
-
-    expect(true).toBe(true);
-  });
-});
-
-describe('a consumer holding only the shared DataSource (#4564)', () => {
-  it('reads the per-home outcomes the adapter actually returns', async () => {
-    const adapter = makeAdapter();
-
-    // The narrowing that makes this a #4564 pin rather than a duplicate of
-    // `deleteView.homes.test.ts`: the receipt below is typed by `DataSource`,
-    // not by `ObjectStackAdapter`. Before the move this assignment compiled
-    // just as well and threw the per-home outcomes away on the way through.
-    const ds: DataSource = adapter;
-
-    const receipt = await ds.deleteView!('account', VIEW);
-
-    // Draft-only view: the draft home held the row, the published one did not.
-    expect(receipt.deleted).toBe(true);
-    expect(receipt.draft?.removed).toBe(true);
-    expect(receipt.published?.removed).toBe(false);
-    expect(receipt.draft?.message).toContain('Draft discarded');
-  });
-});

package/src/errors.test.ts

@@ -1,426 +0,0 @@
-/**
- * ObjectUI
- * Copyright (c) 2024-present ObjectStack Inc.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-import { describe, it, expect } from 'vitest';
-import {
-  ObjectStackError,
-  MetadataNotFoundError,
-  BulkOperationError,
-  ConnectionError,
-  AuthenticationError,
-  DataApiValidationError,
-  createErrorFromResponse,
-  isObjectStackError,
-  isErrorType,
-} from './errors';
-
-describe('Error Classes', () => {
-  describe('ObjectStackError', () => {
-    it('should create base error with all properties', () => {
-      const error = new ObjectStackError(
-        'Test error',
-        'TEST_ERROR',
-        500,
-        { extra: 'info' }
-      );
-
-      expect(error.message).toBe('Test error');
-      expect(error.code).toBe('TEST_ERROR');
-      expect(error.statusCode).toBe(500);
-      expect(error.details).toEqual({ extra: 'info' });
-      expect(error.name).toBe('ObjectStackError');
-      expect(error).toBeInstanceOf(Error);
-      expect(error).toBeInstanceOf(ObjectStackError);
-    });
-
-    it('should work without optional parameters', () => {
-      const error = new ObjectStackError('Test error', 'TEST_ERROR');
-
-      expect(error.message).toBe('Test error');
-      expect(error.code).toBe('TEST_ERROR');
-      expect(error.statusCode).toBeUndefined();
-      expect(error.details).toBeUndefined();
-    });
-
-    it('should convert to JSON correctly', () => {
-      const error = new ObjectStackError(
-        'Test error',
-        'TEST_ERROR',
-        500,
-        { extra: 'info' }
-      );
-
-      const json = error.toJSON();
-      expect(json).toHaveProperty('name', 'ObjectStackError');
-      expect(json).toHaveProperty('message', 'Test error');
-      expect(json).toHaveProperty('code', 'TEST_ERROR');
-      expect(json).toHaveProperty('statusCode', 500);
-      expect(json).toHaveProperty('details', { extra: 'info' });
-      expect(json).toHaveProperty('stack');
-    });
-
-    it('should maintain proper stack trace', () => {
-      const error = new ObjectStackError('Test error', 'TEST_ERROR');
-      expect(error.stack).toBeDefined();
-      expect(error.stack).toContain('ObjectStackError');
-    });
-  });
-
-  describe('MetadataNotFoundError', () => {
-    it('should create metadata not found error', () => {
-      const error = new MetadataNotFoundError('users');
-
-      expect(error.message).toBe('Metadata not found for object: users');
-      expect(error.code).toBe('METADATA_NOT_FOUND');
-      expect(error.statusCode).toBe(404);
-      expect(error.name).toBe('MetadataNotFoundError');
-      expect(error.details).toHaveProperty('objectName', 'users');
-      expect(error).toBeInstanceOf(ObjectStackError);
-      expect(error).toBeInstanceOf(MetadataNotFoundError);
-    });
-
-    it('should include additional details', () => {
-      const error = new MetadataNotFoundError('users', { reason: 'Schema not loaded' });
-
-      expect(error.details).toEqual({
-        objectName: 'users',
-        reason: 'Schema not loaded',
-      });
-    });
-  });
-
-  describe('BulkOperationError', () => {
-    it('should create bulk operation error', () => {
-      const errors = [
-        { index: 0, error: 'Invalid data' },
-        { index: 2, error: 'Duplicate key' },
-      ];
-      
-      const error = new BulkOperationError('create', 8, 2, errors);
-
-      expect(error.message).toBe('Bulk create operation failed: 8 succeeded, 2 failed');
-      expect(error.code).toBe('BULK_OPERATION_ERROR');
-      expect(error.statusCode).toBe(500);
-      expect(error.name).toBe('BulkOperationError');
-      expect(error.successCount).toBe(8);
-      expect(error.failureCount).toBe(2);
-      expect(error.errors).toEqual(errors);
-      expect(error).toBeInstanceOf(ObjectStackError);
-      expect(error).toBeInstanceOf(BulkOperationError);
-    });
-
-    it('should provide operation summary', () => {
-      const errors = [{ index: 0, error: 'Error' }];
-      const error = new BulkOperationError('update', 9, 1, errors);
-
-      const summary = error.getSummary();
-      expect(summary).toEqual({
-        operation: 'update',
-        total: 10,
-        successful: 9,
-        failed: 1,
-        failureRate: 0.1,
-        errors: errors,
-      });
-    });
-
-    it('should handle different operation types', () => {
-      const createError = new BulkOperationError('create', 5, 0, []);
-      const updateError = new BulkOperationError('update', 3, 2, []);
-      const deleteError = new BulkOperationError('delete', 10, 1, []);
-
-      expect(createError.message).toContain('create');
-      expect(updateError.message).toContain('update');
-      expect(deleteError.message).toContain('delete');
-    });
-  });
-
-  describe('ConnectionError', () => {
-    it('should create connection error', () => {
-      const error = new ConnectionError(
-        'Network timeout',
-        'https://api.example.com'
-      );
-
-      expect(error.message).toBe('Connection error: Network timeout');
-      expect(error.code).toBe('CONNECTION_ERROR');
-      expect(error.statusCode).toBe(503);
-      expect(error.name).toBe('ConnectionError');
-      expect(error.url).toBe('https://api.example.com');
-      expect(error).toBeInstanceOf(ObjectStackError);
-      expect(error).toBeInstanceOf(ConnectionError);
-    });
-
-    it('should work without URL', () => {
-      const error = new ConnectionError('Network timeout');
-
-      expect(error.url).toBeUndefined();
-      expect(error.message).toBe('Connection error: Network timeout');
-    });
-  });
-
-  describe('AuthenticationError', () => {
-    it('should create authentication error', () => {
-      const error = new AuthenticationError();
-
-      expect(error.message).toBe('Authentication failed');
-      expect(error.code).toBe('AUTHENTICATION_ERROR');
-      expect(error.statusCode).toBe(401);
-      expect(error.name).toBe('AuthenticationError');
-      expect(error).toBeInstanceOf(ObjectStackError);
-      expect(error).toBeInstanceOf(AuthenticationError);
-    });
-
-    it('should accept custom message', () => {
-      const error = new AuthenticationError('Invalid API token');
-
-      expect(error.message).toBe('Invalid API token');
-    });
-
-    it('should include additional details', () => {
-      const error = new AuthenticationError('Invalid token', { token: 'abc123' });
-
-      expect(error.details).toEqual({ token: 'abc123' });
-    });
-  });
-
-  describe('DataApiValidationError', () => {
-    it('should create validation error', () => {
-      const error = new DataApiValidationError('Invalid input');
-
-      expect(error.message).toBe('Invalid input');
-      expect(error.code).toBe('VALIDATION_ERROR');
-      expect(error.statusCode).toBe(400);
-      expect(error.name).toBe('ValidationError');
-      expect(error).toBeInstanceOf(ObjectStackError);
-      expect(error).toBeInstanceOf(DataApiValidationError);
-    });
-
-    it('should include field information', () => {
-      const error = new DataApiValidationError('Email is invalid', 'email');
-
-      expect(error.field).toBe('email');
-      expect(error.details).toHaveProperty('field', 'email');
-    });
-
-    it('should include validation errors array', () => {
-      const validationErrors = [
-        { field: 'email', message: 'Invalid email format' },
-        { field: 'age', message: 'Must be a positive number' },
-      ];
-      
-      const error = new DataApiValidationError(
-        'Validation failed',
-        undefined,
-        validationErrors
-      );
-
-      expect(error.validationErrors).toEqual(validationErrors);
-      expect(error.getValidationErrors()).toEqual(validationErrors);
-    });
-
-    it('should return empty array when no validation errors', () => {
-      const error = new DataApiValidationError('Validation failed');
-
-      expect(error.getValidationErrors()).toEqual([]);
-    });
-  });
-});
-
-describe('Error Helpers', () => {
-  describe('createErrorFromResponse', () => {
-    it('should create AuthenticationError for 401 status', () => {
-      const response = {
-        status: 401,
-        message: 'Unauthorized',
-        data: null,
-      };
-
-      const error = createErrorFromResponse(response, 'API request');
-
-      expect(error).toBeInstanceOf(AuthenticationError);
-      expect(error.message).toBe('Unauthorized');
-      expect(error.statusCode).toBe(401);
-    });
-
-    it('should create AuthenticationError for 403 status', () => {
-      const response = {
-        status: 403,
-        message: 'Forbidden',
-      };
-
-      const error = createErrorFromResponse(response);
-
-      expect(error).toBeInstanceOf(AuthenticationError);
-      expect(error.statusCode).toBe(403);
-    });
-
-    it('should create MetadataNotFoundError for 404 with metadata context', () => {
-      const response = {
-        status: 404,
-        message: 'Not found',
-      };
-
-      const error = createErrorFromResponse(response, 'getObjectSchema(users)');
-
-      expect(error).toBeInstanceOf(MetadataNotFoundError);
-      expect(error.statusCode).toBe(404);
-      expect((error as MetadataNotFoundError).details?.objectName).toBe('users');
-    });
-
-    it('should create generic error for 404 without metadata context', () => {
-      const response = {
-        status: 404,
-        message: 'Not found',
-      };
-
-      const error = createErrorFromResponse(response, 'data request');
-
-      expect(error).toBeInstanceOf(ObjectStackError);
-      expect(error).not.toBeInstanceOf(MetadataNotFoundError);
-      expect(error.code).toBe('NOT_FOUND');
-    });
-
-    it('should create DataApiValidationError for 400 status', () => {
-      const response = {
-        status: 400,
-        message: 'Bad request',
-        data: {
-          errors: [
-            { field: 'email', message: 'Invalid email' },
-          ],
-        },
-      };
-
-      const error = createErrorFromResponse(response);
-
-      expect(error).toBeInstanceOf(DataApiValidationError);
-      expect(error.statusCode).toBe(400);
-      expect((error as DataApiValidationError).validationErrors).toEqual([
-        { field: 'email', message: 'Invalid email' },
-      ]);
-    });
-
-    it('should create ConnectionError for 503 status', () => {
-      const response = {
-        status: 503,
-        message: 'Service unavailable',
-        config: { url: 'https://api.example.com' },
-      };
-
-      const error = createErrorFromResponse(response);
-
-      expect(error).toBeInstanceOf(ConnectionError);
-      expect(error.statusCode).toBe(503);
-      expect((error as ConnectionError).url).toBe('https://api.example.com');
-    });
-
-    it('should create ConnectionError for 504 status', () => {
-      const response = {
-        status: 504,
-        message: 'Gateway timeout',
-      };
-
-      const error = createErrorFromResponse(response);
-
-      expect(error).toBeInstanceOf(ConnectionError);
-      expect(error.statusCode).toBe(504);
-    });
-
-    it('should create generic error for unknown status', () => {
-      const response = {
-        status: 418,
-        message: "I'm a teapot",
-      };
-
-      const error = createErrorFromResponse(response);
-
-      expect(error).toBeInstanceOf(ObjectStackError);
-      expect(error.code).toBe('UNKNOWN_ERROR');
-      expect(error.statusCode).toBe(418);
-    });
-
-    it('should handle response without status code', () => {
-      const response = {
-        message: 'Unknown error',
-      };
-
-      const error = createErrorFromResponse(response);
-
-      expect(error).toBeInstanceOf(ObjectStackError);
-      expect(error.statusCode).toBe(500);
-    });
-
-    it('should include context in error details', () => {
-      const response = {
-        status: 500,
-        message: 'Server error',
-      };
-
-      const error = createErrorFromResponse(response, 'user creation');
-
-      expect(error.details).toHaveProperty('context', 'user creation');
-    });
-  });
-
-  describe('isObjectStackError', () => {
-    it('should return true for ObjectStackError instances', () => {
-      const error = new ObjectStackError('Test', 'TEST');
-      expect(isObjectStackError(error)).toBe(true);
-    });
-
-    it('should return true for derived error classes', () => {
-      const metadataError = new MetadataNotFoundError('users');
-      const bulkError = new BulkOperationError('create', 0, 1, []);
-      const connError = new ConnectionError('timeout');
-      const authError = new AuthenticationError();
-      const validError = new DataApiValidationError('invalid');
-
-      expect(isObjectStackError(metadataError)).toBe(true);
-      expect(isObjectStackError(bulkError)).toBe(true);
-      expect(isObjectStackError(connError)).toBe(true);
-      expect(isObjectStackError(authError)).toBe(true);
-      expect(isObjectStackError(validError)).toBe(true);
-    });
-
-    it('should return false for regular Error', () => {
-      const error = new Error('Regular error');
-      expect(isObjectStackError(error)).toBe(false);
-    });
-
-    it('should return false for non-error values', () => {
-      expect(isObjectStackError(null)).toBe(false);
-      expect(isObjectStackError(undefined)).toBe(false);
-      expect(isObjectStackError('error')).toBe(false);
-      expect(isObjectStackError({})).toBe(false);
-    });
-  });
-
-  describe('isErrorType', () => {
-    it('should return true for matching error type', () => {
-      const error = new MetadataNotFoundError('users');
-      expect(isErrorType(error, MetadataNotFoundError)).toBe(true);
-    });
-
-    it('should return false for non-matching error type', () => {
-      const error = new MetadataNotFoundError('users');
-      expect(isErrorType(error, DataApiValidationError)).toBe(false);
-    });
-
-    it('should return true for base class check', () => {
-      const error = new MetadataNotFoundError('users');
-      expect(isErrorType(error, ObjectStackError)).toBe(true);
-    });
-
-    it('should return false for non-error values', () => {
-      expect(isErrorType(null, ObjectStackError)).toBe(false);
-      expect(isErrorType(undefined, ObjectStackError)).toBe(false);
-      expect(isErrorType({}, ObjectStackError)).toBe(false);
-    });
-  });
-});