fix: use code for OperationError

Author: kettanaito

README.md

@@ -432,9 +432,8 @@ Data provides multiple different error classes to help you differentiate and han
 
 ### `OperationError`
 
-- `operationName` `<string>`, the name of the errored operation (e.g. "create", "updateMany", etc.);
-- `info` `<object>`, additional operation information (often the operation arguments);
-- `cause` `<Error>`, a reference to the original thrown error.
+- `code` `<OperationErrorCode>`, the error code describing the failed operation;
+- `cause` `<Error>` (_optional_), a reference to the original thrown error.
 
 Thrown whenever performing a record operation fails. For example:
 

src/collection.ts

@@ -19,7 +19,7 @@ import {
 } from '#/src/utils.js'
 import { type SortOptions, sortResults } from '#/src/sort.js'
 import type { Extension } from '#/src/extensions/index.js'
-import { OperationError, StrictOperationError } from '#/src/errors.js'
+import { OperationError, OperationErrorCodes } from '#/src/errors.js'
 import { TypedEvent, type Emitter } from 'rettime'
 
 let collectionsCreated = 0
@@ -131,16 +131,16 @@ export class Collection<Schema extends StandardSchemaV1> {
 
     if (validationResult.issues) {
       console.error(validationResult.issues)
-      throw new InvariantError(
-        'Failed to create a new record with initial values (%j): does not match the schema',
-        initialValues,
+      throw new OperationError(
+        'Failed to create a new record with initial values (%j): does not match the schema. Please see the schema validation errors above.',
+        OperationErrorCodes.INVALID_INITIAL_VALUES,
       )
     }
 
     let record = validationResult.value as RecordType
 
     invariant.as(
-      OperationError.for('create', { initialValues }),
+      OperationError.for(OperationErrorCodes.INVALID_INITIAL_VALUES),
       typeof record === 'object',
       'Failed to create a record with initial values (%j): expected the record to be an object or an array',
       initialValues,
@@ -207,8 +207,7 @@ export class Collection<Schema extends StandardSchemaV1> {
     return await Promise.all(pendingPromises).catch((error) => {
       throw new OperationError(
         'Failed to execute "createMany" on collection: unexpected error',
-        'createMany',
-        { count, initialValuesFactory },
+        OperationErrorCodes.UNEXPECTED_ERROR,
         error,
       )
     })
@@ -232,7 +231,7 @@ export class Collection<Schema extends StandardSchemaV1> {
       const firstRecord = this.#records[0]
 
       invariant.as(
-        StrictOperationError.for('findFirst', { predicate, options }),
+        OperationError.for(OperationErrorCodes.STRICT_QUERY_WITHOUT_RESULTS),
         options?.strict ? firstRecord != null : true,
         'Failed to execute "findFirst" on collection without a query: the collection is empty',
       )
@@ -245,7 +244,7 @@ export class Collection<Schema extends StandardSchemaV1> {
     ).next().value
 
     invariant.as(
-      StrictOperationError.for('findFirst', { predicate, options }),
+      OperationError.for(OperationErrorCodes.STRICT_QUERY_WITHOUT_RESULTS),
       options?.strict ? result != null : true,
       'Failed to execute "findFirst" on collection: no record found matching the query',
     )
@@ -277,7 +276,7 @@ export class Collection<Schema extends StandardSchemaV1> {
     )
 
     invariant.as(
-      StrictOperationError.for('findMany', { predicate, options }),
+      OperationError.for(OperationErrorCodes.STRICT_QUERY_WITHOUT_RESULTS),
       options?.strict ? results.length > 0 : true,
       'Failed to execute "findMany" on collection: no records found matching the query',
     )
@@ -324,7 +323,7 @@ export class Collection<Schema extends StandardSchemaV1> {
 
     if (prevRecord == null) {
       invariant.as(
-        StrictOperationError.for('update', { predicate, options }),
+        OperationError.for(OperationErrorCodes.STRICT_QUERY_WITHOUT_RESULTS),
         !options.strict,
         'Failed to execute "update" on collection: no record found matching the query',
       )
@@ -363,7 +362,7 @@ export class Collection<Schema extends StandardSchemaV1> {
 
     if (prevRecords.length === 0) {
       invariant.as(
-        StrictOperationError.for('updateMany', { predicate, options }),
+        OperationError.for(OperationErrorCodes.STRICT_QUERY_WITHOUT_RESULTS),
         !options.strict,
         'Failed to execute "updateMany" on collection: no records found matching the query',
       )
@@ -409,7 +408,7 @@ export class Collection<Schema extends StandardSchemaV1> {
 
     if (record == null) {
       invariant.as(
-        StrictOperationError.for('delete', { predicate, options }),
+        OperationError.for(OperationErrorCodes.STRICT_QUERY_WITHOUT_RESULTS),
         !options?.strict,
         'Failed to execute "delete" on collection: no record found matching the query',
       )
@@ -445,7 +444,7 @@ export class Collection<Schema extends StandardSchemaV1> {
 
     if (records.length === 0) {
       invariant.as(
-        StrictOperationError.for('deleteMany', { predicate, options }),
+        OperationError.for(OperationErrorCodes.STRICT_QUERY_WITHOUT_RESULTS),
         !options?.strict,
         'Failed to execute "deleteMany" on collection: no records found matching the query',
       )

src/errors.ts

@@ -1,72 +1,29 @@
-import { InvariantError } from 'outvariant'
 import type { Collection } from '#/src/collection.js'
 import type { PropertyPath } from '#/src/utils.js'
 import type { RelationDeclarationOptions } from '#/src/relation.js'
 
-export interface OperationErrorMap {
-  create: {
-    initialValues: Parameters<InstanceType<typeof Collection>['create']>[0]
-  }
-  createMany: {
-    count: number
-    initialValuesFactory: Parameters<
-      InstanceType<typeof Collection>['createMany']
-    >[1]
-  }
-  findFirst: {
-    predicate: Parameters<InstanceType<typeof Collection>['findFirst']>[0]
-    options: Parameters<InstanceType<typeof Collection>['findFirst']>[1]
-  }
-  findMany: {
-    predicate: Parameters<InstanceType<typeof Collection>['findMany']>[0]
-    options: Parameters<InstanceType<typeof Collection>['findMany']>[1]
-  }
-  update: {
-    predicate: Parameters<InstanceType<typeof Collection>['update']>[0]
-    options: Parameters<InstanceType<typeof Collection>['update']>[1]
-  }
-  updateMany: {
-    predicate: Parameters<InstanceType<typeof Collection>['updateMany']>[0]
-    options: Parameters<InstanceType<typeof Collection>['updateMany']>[1]
-  }
-  delete: {
-    predicate: Parameters<InstanceType<typeof Collection>['delete']>[0]
-    options: Parameters<InstanceType<typeof Collection>['delete']>[1]
-  }
-  deleteMany: {
-    predicate: Parameters<InstanceType<typeof Collection>['deleteMany']>[0]
-    options: Parameters<InstanceType<typeof Collection>['deleteMany']>[1]
-  }
+export enum OperationErrorCodes {
+  UNEXPECTED_ERROR = 'UNEXPECTED_ERROR',
+  INVALID_INITIAL_VALUES = 'INVALID_INITIAL_VALUES',
+  STRICT_QUERY_WITHOUT_RESULTS = 'STRICT_QUERY_WITHOUT_RESULTS',
 }
 
-export class OperationError<
-  OperationName extends keyof OperationErrorMap,
-> extends InvariantError {
-  static for<OperationName extends keyof OperationErrorMap>(
-    operationName: OperationName,
-    info: OperationErrorMap[OperationName],
-  ) {
+export class OperationError extends Error {
+  static for(code: OperationErrorCodes) {
     return (message: string) => {
-      return new OperationError(message, operationName, info)
+      return new OperationError(message, code)
     }
   }
 
   constructor(
     message: string,
-    public readonly operationName: OperationName,
-    public readonly info: OperationErrorMap[OperationName],
+    public readonly code: OperationErrorCodes,
     public readonly cause?: unknown,
   ) {
     super(message)
   }
 }
 
-export class StrictOperationError<
-  OperationName extends keyof OperationErrorMap,
-> extends OperationError<OperationName> {
-  static for = OperationError.for
-}
-
 export enum RelationErrorCodes {
   RELATION_NOT_READY = 'RELATION_NOT_READY',
   UNEXPECTED_SET_EXPRESSION = 'UNEXPECTED_SET_EXPRESSION',