@opra/common 0.32.5 → 0.33.0

package/types/exception/resource-errors/resource-not.available.error.d.ts

@@ -0,0 +1,8 @@
+import { OpraException } from '../opra-exception.js';
+/**
+ * The server cannot find the requested resource.
+ * This can also mean that the endpoint is valid but the resource itself does not exist.
+ */
+export declare class ResourceNotAvailableError extends OpraException {
+    constructor(resource: string, keyValue?: any, cause?: Error);
+}

package/types/filter/errors.d.ts

@@ -2,7 +2,7 @@ import { RecognitionException } from '@browsery/antlr4';
 import { Recognizer } from '@browsery/antlr4/typings/Recognizer';
 export declare class SyntaxError extends TypeError {
 }
-export declare class ValidationError extends TypeError {
+export declare class FilterValidationError extends TypeError {
     constructor(message?: string | {
         message?: string;
     });

package/types/helpers/object-utils.d.ts

@@ -1,4 +1,4 @@
-import { HighDeepRemoveNulls } from 'ts-gems';
+import { DeeperOmitTypes } from 'ts-gems';
 export declare function cloneObject<T extends {}>(obj: T, jsonOnly?: boolean): T;
 export declare function omitUndefined<T>(obj: T, recursive?: boolean): T;
-export declare function omitNullish<T>(obj: T, recursive?: boolean): HighDeepRemoveNulls<T>;
+export declare function omitNullish<T>(obj: T, recursive?: boolean): DeeperOmitTypes<T, null | undefined>;

package/types/schema/data-type/complex-type.interface.d.ts

@@ -13,5 +13,5 @@ export interface ComplexType extends StrictOmit<DataTypeBase, 'kind'> {
 }
 export declare namespace ComplexType {
     const Kind = "ComplexType";
-    type Kind = 'ComplexType';
+    type Kind = typeof Kind;
 }

package/types/schema/data-type/field.interface.d.ts

@@ -50,7 +50,10 @@ export type Field = {
      * Indicates if the field is deprecated and can be removed in the next
      */
     deprecated?: boolean | string;
-    format?: string;
+    /**
+     * Defines RegExp pattern for the field. A String type is required for this option
+     */
+    pattern?: string;
     /**
      * Indicates if partial update enabled for this field
      */

package/types/schema/data-type/mapped-type.interface.d.ts

@@ -9,5 +9,5 @@ export interface MappedType extends StrictOmit<ComplexType, 'kind'> {
 }
 export declare namespace MappedType {
     const Kind = "MappedType";
-    type Kind = 'MappedType';
+    type Kind = typeof Kind;
 }

package/types/schema/data-type/simple-type.interface.d.ts

@@ -1,12 +1,12 @@
 import { StrictOmit } from 'ts-gems';
-import * as vg from 'valgen';
+import { Validator } from 'valgen';
 import type { DataTypeBase } from './data-type.interface.js';
 import { DataType } from './data-type.interface.js';
 export interface SimpleType extends StrictOmit<DataTypeBase, 'kind'> {
     kind: SimpleType.Kind;
     base?: DataType.Name | SimpleType;
-    decoder?: vg.Validator;
-    encoder?: vg.Validator;
+    decoder?: Validator;
+    encoder?: Validator;
 }
 export declare namespace SimpleType {
     const Kind = "SimpleType";

package/types/types.d.ts

@@ -1,4 +1,4 @@
-import type { IfNoDeepValue, IfUndefined, OmitNever, Type, WritableKeys } from 'ts-gems';
+import type { DeeperNullish, DeeperPartial, IfNever, IfNoDeepValue, Type } from 'ts-gems';
 export type Thunk<T> = T | (() => T);
 export type ThunkAsync<T> = Thunk<T> | Thunk<Promise<T>>;
 export type TypeThunk<T = any> = Thunk<Type<T>>;
@@ -7,16 +7,8 @@ export type TypeThunkAsync<T = any> = ThunkAsync<Type<T>>;
  * Returns given type as a Data Transfer Object (DTO) interface, Removes symbol keys and function properties.
  * @template T - The type of the data being transferred.
  */
-export type DTO<T> = _DTO<Exclude<T, undefined>>;
-type _DTO<T, K extends keyof T = WritableKeys<T>> = T extends (infer U)[] ? DTO<U>[] : IfNoDeepValue<T> extends true ? T : OmitNever<{
-    [P in K]: P extends symbol ? never : T[P] extends Function ? never : DTO<Exclude<T[P], undefined>>;
-}>;
-export type PartialDTO<T> = _PartialDTO<Exclude<T, undefined>>;
-type _PartialDTO<T, K extends keyof T = WritableKeys<T>> = T extends (infer U)[] ? PartialDTO<U>[] : IfNoDeepValue<T> extends true ? T : OmitNever<{
-    [P in K]?: P extends symbol ? never : T[P] extends Function ? never : PartialDTO<Exclude<T[P], undefined>>;
-}>;
-export type PatchDTO<T> = _PatchDTO<Exclude<T, undefined>>;
-type _PatchDTO<T, K extends keyof T = WritableKeys<T>> = T extends (infer U)[] ? PatchDTO<U>[] : IfNoDeepValue<T> extends true ? T : OmitNever<{
-    [P in K]?: P extends symbol ? never : T[P] extends Function ? never : IfUndefined<T> extends true ? T[P] : PatchDTO<Exclude<T[P], undefined>> | null;
-}>;
-export {};
+export type DTO<T> = {
+    [K in keyof T as (IfNever<Exclude<T[K], undefined | Function>, never, K>)]: Exclude<T[K], undefined | null> extends (infer U)[] ? DTO<U>[] : IfNoDeepValue<Exclude<T[K], undefined | null>> extends true ? Exclude<T[K], undefined | null> : DTO<Exclude<T[K], undefined | null>>;
+};
+export type PartialDTO<T> = DeeperPartial<DTO<T>>;
+export type PatchDTO<T> = DeeperNullish<DTO<T>>;

package/cjs/exception/common-errors/validation.error.js

@@ -1,11 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ValidationError = void 0;
-const opra_exception_js_1 = require("../opra-exception.js");
-class ValidationError extends opra_exception_js_1.OpraException {
-    constructor() {
-        super(...arguments);
-        this.status = 400;
-    }
-}
-exports.ValidationError = ValidationError;

package/esm/exception/common-errors/validation.error.js

@@ -1,7 +0,0 @@
-import { OpraException } from '../opra-exception.js';
-export class ValidationError extends OpraException {
-    constructor() {
-        super(...arguments);
-        this.status = 400;
-    }
-}

package/types/exception/common-errors/validation.error.d.ts

@@ -1,4 +0,0 @@
-import { OpraException } from '../opra-exception.js';
-export declare class ValidationError extends OpraException {
-    status: number;
-}