@sapporta/rest-core 3.52.1 → 3.52.2

package/src/lib/standard-schema.d.ts

@@ -0,0 +1,55 @@
+/** The Standard Schema interface. */
+export interface StandardSchemaV1<Input = unknown, Output = Input> {
+    /** The Standard Schema properties. */
+    readonly '~standard': StandardSchemaV1.Props<Input, Output>;
+}
+export declare namespace StandardSchemaV1 {
+    /** The Standard Schema properties interface. */
+    interface Props<Input = unknown, Output = Input> {
+        /** The version number of the standard. */
+        readonly version: 1;
+        /** The vendor name of the schema library. */
+        readonly vendor: string;
+        /** Validates unknown input values. */
+        readonly validate: (value: unknown) => Result<Output> | Promise<Result<Output>>;
+        /** Inferred types associated with the schema. */
+        readonly types?: Types<Input, Output> | undefined;
+    }
+    /** The result interface of the validate function. */
+    type Result<Output> = SuccessResult<Output> | FailureResult;
+    /** The result interface if validation succeeds. */
+    interface SuccessResult<Output> {
+        /** The typed output value. */
+        readonly value: Output;
+        /** The non-existent issues. */
+        readonly issues?: undefined;
+    }
+    /** The result interface if validation fails. */
+    interface FailureResult {
+        /** The issues of failed validation. */
+        readonly issues: ReadonlyArray<Issue>;
+    }
+    /** The issue interface of the failure output. */
+    interface Issue {
+        /** The error message of the issue. */
+        readonly message: string;
+        /** The path of the issue, if any. */
+        readonly path?: ReadonlyArray<PropertyKey | PathSegment> | undefined;
+    }
+    /** The path segment interface of the issue. */
+    interface PathSegment {
+        /** The key representing a path segment. */
+        readonly key: PropertyKey;
+    }
+    /** The Standard Schema types interface. */
+    interface Types<Input = unknown, Output = Input> {
+        /** The input type of the schema. */
+        readonly input: Input;
+        /** The output type of the schema. */
+        readonly output: Output;
+    }
+    /** Infers the input type of a Standard Schema. */
+    type InferInput<Schema extends StandardSchemaV1> = NonNullable<Schema['~standard']['types']>['input'];
+    /** Infers the output type of a Standard Schema. */
+    type InferOutput<Schema extends StandardSchemaV1> = NonNullable<Schema['~standard']['types']>['output'];
+}

package/src/lib/status-codes.d.ts

@@ -0,0 +1,6 @@
+export type SuccessfulHttpStatusCode = 200 | 201 | 202 | 203 | 204 | 205 | 206 | 207;
+/**
+ * All available HTTP Status codes
+ */
+export type HTTPStatusCode = 100 | 101 | 102 | 200 | 201 | 202 | 203 | 204 | 205 | 206 | 207 | 300 | 301 | 302 | 303 | 304 | 305 | 307 | 308 | 400 | 401 | 402 | 403 | 404 | 405 | 406 | 407 | 408 | 409 | 410 | 411 | 412 | 413 | 414 | 415 | 416 | 417 | 418 | 419 | 420 | 421 | 422 | 423 | 424 | 428 | 429 | 431 | 451 | 500 | 501 | 502 | 503 | 504 | 505 | 507 | 511;
+export type ErrorHttpStatusCode = Exclude<HTTPStatusCode, SuccessfulHttpStatusCode>;

package/src/lib/{test-helpers.ts → test-helpers.d.ts}

@@ -1,7 +1,2 @@
-export type Equal<a, b> = (<T>() => T extends a ? 1 : 2) extends <
-  T,
->() => T extends b ? 1 : 2
-  ? true
-  : false;
-
+export type Equal<a, b> = (<T>() => T extends a ? 1 : 2) extends <T>() => T extends b ? 1 : 2 ? true : false;
 export type Expect<a extends true> = a;

package/src/lib/type-guards.d.ts

@@ -0,0 +1,12 @@
+import { AppRoute } from './dsl';
+import { ClientInferResponses, InferResponseUndefinedStatusCodes } from './infer-types';
+import { ErrorHttpStatusCode, HTTPStatusCode, SuccessfulHttpStatusCode } from './status-codes';
+export declare const isResponse: <T extends AppRoute>(response: unknown, contractEndpoint?: T | undefined) => response is ClientInferResponses<T, HTTPStatusCode>;
+export declare const isSuccessResponse: <T extends AppRoute>(response: unknown, contractEndpoint?: T | undefined) => response is ClientInferResponses<T, SuccessfulHttpStatusCode>;
+export declare const isErrorResponse: <T extends AppRoute>(response: unknown, contractEndpoint?: T | undefined) => response is ClientInferResponses<T, ErrorHttpStatusCode>;
+export declare const isUnknownResponse: <T extends AppRoute>(response: unknown, contractEndpoint: T) => response is ClientInferResponses<T, InferResponseUndefinedStatusCodes<T>, "ignore">;
+export declare const isUnknownSuccessResponse: <T extends AppRoute>(response: unknown, contractEndpoint: T) => response is ClientInferResponses<T, InferResponseUndefinedStatusCodes<T, SuccessfulHttpStatusCode>, "ignore">;
+export declare const isUnknownErrorResponse: <T extends AppRoute>(response: unknown, contractEndpoint: T) => response is ClientInferResponses<T, InferResponseUndefinedStatusCodes<T, ErrorHttpStatusCode>, "ignore">;
+export declare const exhaustiveGuard: <T extends {
+    status: never;
+}>(response: T) => never;

package/src/lib/type-utils.d.ts

@@ -0,0 +1,96 @@
+import type { z } from 'zod';
+import { ContractNoBodyType, ContractNullType, ContractPlainType } from './dsl';
+import { StandardSchemaV1 } from './standard-schema';
+type GetIndexedField<T, K> = K extends keyof T ? T[K] : K extends `${number}` ? '0' extends keyof T ? undefined : number extends keyof T ? T[number] : undefined : undefined;
+type FieldWithPossiblyUndefined<T, Key> = GetFieldType<Exclude<T, undefined>, Key> | Extract<T, undefined>;
+type IndexedFieldWithPossiblyUndefined<T, Key> = GetIndexedField<Exclude<T, undefined>, Key> | Extract<T, undefined>;
+export type GetFieldType<T, P> = P extends `${infer Left}.${infer Right}` ? Left extends keyof T ? FieldWithPossiblyUndefined<T[Left], Right> : Left extends `${infer FieldKey}[${infer IndexKey}]` ? FieldKey extends keyof T ? FieldWithPossiblyUndefined<IndexedFieldWithPossiblyUndefined<T[FieldKey], IndexKey>, Right> : undefined : undefined : P extends keyof T ? T[P] : P extends `${infer FieldKey}[${infer IndexKey}]` ? FieldKey extends keyof T ? IndexedFieldWithPossiblyUndefined<T[FieldKey], IndexKey> : undefined : undefined;
+type ExcludeKeysWithTypeOf<T, V> = {
+    [K in keyof T]-?: [Exclude<T[K], undefined>] extends [V] ? never : K;
+}[keyof T];
+type ExcludeKeysWithoutTypeOf<T, V> = {
+    [K in keyof T]-?: [Exclude<T[K], undefined>] extends [V] ? K : never;
+}[keyof T];
+export type Without<T, V> = Pick<T, ExcludeKeysWithTypeOf<T, V>>;
+export type With<T, V> = Pick<T, ExcludeKeysWithoutTypeOf<T, V>>;
+export type SchemaOutputOrType<T> = T extends ContractNullType ? null : T extends ContractNoBodyType ? undefined : T extends ContractPlainType<infer U> ? U : T extends z.ZodTypeAny ? z.output<T> : T extends StandardSchemaV1 ? StandardSchemaV1.InferOutput<T> : T;
+/** @deprecated use SchemaOutputOrType */
+export type ZodInferOrType<T> = SchemaOutputOrType<T>;
+export type SchemaInputOrType<T> = T extends ContractNullType ? null : T extends ContractNoBodyType ? undefined : T extends ContractPlainType<infer U> ? U : T extends z.ZodTypeAny ? z.input<T> : T extends StandardSchemaV1 ? StandardSchemaV1.InferInput<T> : T;
+/** @deprecated use SchemaInputOrType */
+export type ZodInputOrType<T> = SchemaInputOrType<T>;
+export type Merge<T, U> = Omit<T, keyof U> & U;
+type Try<A, B, C> = A extends B ? A : C;
+type NarrowRaw<T> = (T extends Function ? T : never) | (T extends string | number | bigint | boolean ? T : never) | (T extends [] ? [] : never) | {
+    [K in keyof T]: K extends 'description' ? T[K] : NarrowNotSchema<T[K]>;
+};
+type NarrowNotSchema<T> = Try<T, StandardSchemaV1, NarrowRaw<T>>;
+export type Narrow<T> = Try<T, [], NarrowNotSchema<T>>;
+export type PartialBy<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
+/**
+ * Makes the properties of `T` specified by `K` optional, where `K` can be any type (not necessarily keys of `T`).
+ * If `K` is not a key of `T`, it is ignored.
+ *
+ * @template T - The base object type.
+ * @template K - The keys to make optional (can be any type, only keys of `T` are used).
+ */
+export type PartialByLooseKeys<T, K> = Omit<T, K extends keyof T ? K : never> & Partial<Pick<T, K extends keyof T ? K : never>>;
+type OptionalKeys<T> = T extends unknown ? {
+    [K in keyof T]-?: undefined extends {
+        [K2 in keyof T]: K2;
+    }[K] ? K : never;
+}[keyof T] : never;
+export type AreAllPropertiesOptional<T> = T extends Record<string, unknown> ? Exclude<keyof T, OptionalKeys<T>> extends never ? true : false : false;
+export type IfAllPropertiesOptional<T, TIf, TElse> = T extends Record<string, unknown> ? Exclude<keyof T, OptionalKeys<T>> extends never ? TIf : TElse : TElse;
+export type OptionalIfAllOptional<T, Select extends keyof T = keyof T> = PartialBy<T, Select & {
+    [K in keyof T]: AreAllPropertiesOptional<T[K]> extends true ? K : never;
+}[keyof T]>;
+export type Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+export type DefinedOrEmpty<T, K extends keyof NonNullable<T>> = undefined extends T ? {} : NonNullable<T>[K];
+declare const tag: unique symbol;
+declare type Tagged<Token> = {
+    readonly [tag]: Token;
+};
+export type Opaque<Type, Token = unknown> = Type & Tagged<Token>;
+export type UnwrapOpaque<OpaqueType extends Tagged<unknown>> = OpaqueType extends Opaque<infer Type, OpaqueType[typeof tag]> ? Type : OpaqueType;
+export type WithoutUnknown<T> = Pick<T, {
+    [K in keyof T]: unknown extends Exclude<T[K], undefined> ? never : K;
+}[keyof T]>;
+export type LowercaseKeys<T> = Prettify<{
+    [K in keyof T as K extends string ? Lowercase<K> : K]: T[K];
+}>;
+export type Extends<T, U> = T extends U ? true : false;
+export type And<B1 extends boolean, B2 extends boolean> = {
+    false: {
+        false: false;
+        true: false;
+    };
+    true: {
+        false: false;
+        true: true;
+    };
+}[`${B1}`][`${B2}`];
+export type Or<B1 extends boolean, B2 extends boolean> = {
+    false: {
+        false: false;
+        true: true;
+    };
+    true: {
+        false: true;
+        true: true;
+    };
+}[`${B1}`][`${B2}`];
+export type Not<B extends boolean> = {
+    false: true;
+    true: false;
+}[`${B}`];
+type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
+type CommonKeys<T, R = {}> = R extends T ? keyof T & CommonKeys<Exclude<T, R>> : keyof T;
+type Common<T> = Pick<T, CommonKeys<T>>;
+type RemoveUnionProperties<T> = {
+    [TKey in keyof T as [T[TKey]] extends [UnionToIntersection<T[TKey]>] ? TKey : never]: T[TKey];
+};
+export type CommonAndEqual<T> = RemoveUnionProperties<Common<T>>;
+export {};

package/src/lib/unknown-status-error.d.ts

@@ -0,0 +1,10 @@
+export declare class UnknownStatusError extends Error {
+    response: {
+        status: number;
+        body: unknown;
+    };
+    constructor(response: {
+        status: number;
+        body: unknown;
+    }, knownResponseStatuses: string[]);
+}

package/src/lib/validation-error.d.ts

@@ -0,0 +1,11 @@
+import { StandardSchemaV1 } from './standard-schema';
+/**
+ * The error class for standard schema validation errors.
+ *
+ * @see {@link StandardSchemaV1.FailureResult}
+ */
+export declare class StandardSchemaError extends Error implements StandardSchemaV1.FailureResult {
+    readonly issues: readonly StandardSchemaV1.Issue[];
+    constructor(issues: ReadonlyArray<StandardSchemaV1.Issue>);
+    toString(): string;
+}

package/.babelrc

@@ -1,10 +0,0 @@
-{
-  "presets": [
-    [
-      "@nrwl/js/babel",
-      {
-        "useBuiltIns": "usage"
-      }
-    ]
-  ]
-}

package/.eslintrc.json

@@ -1,21 +0,0 @@
-{
-  "extends": ["../../../.eslintrc.json"],
-  "ignorePatterns": ["!**/*"],
-  "overrides": [
-    {
-      "files": ["*.ts", "*.tsx", "*.js", "*.jsx"],
-      "rules": {
-        "@typescript-eslint/no-unused-vars": ["warn"],
-        "@typescript-eslint/no-explicit-any": ["warn"]
-      }
-    },
-    {
-      "files": ["*.ts", "*.tsx"],
-      "rules": {}
-    },
-    {
-      "files": ["*.js", "*.jsx"],
-      "rules": {}
-    }
-  ]
-}

package/LICENCE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2022 Oliver Butler
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

package/jest.config.ts

@@ -1,16 +0,0 @@
-/* eslint-disable */
-export default {
-  displayName: 'sapporta-rest-core',
-  preset: '../../../jest.preset.js',
-  globals: {},
-  transform: {
-    '^.+\\.[tj]s$': [
-      'ts-jest',
-      {
-        tsconfig: '<rootDir>/tsconfig.spec.json',
-      },
-    ],
-  },
-  moduleFileExtensions: ['ts', 'js', 'html'],
-  testEnvironment: 'node',
-};

package/project.json

@@ -1,51 +0,0 @@
-{
-  "name": "sapporta-rest-core",
-  "$schema": "../../../node_modules/nx/schemas/project-schema.json",
-  "sourceRoot": "libs/ts-rest/core/src",
-  "projectType": "library",
-  "targets": {
-    "build": {
-      "executor": "@nx/rollup:rollup",
-      "outputs": ["{options.outputPath}"],
-      "options": {
-        "project": "libs/ts-rest/core/package.json",
-        "outputPath": "dist/libs/ts-rest/core",
-        "main": "libs/ts-rest/core/src/index.ts",
-        "tsConfig": "libs/ts-rest/core/tsconfig.lib.json",
-        "assets": [
-          {
-            "glob": "CHANGELOG.md",
-            "input": "libs/ts-rest/core",
-            "output": "."
-          },
-          {
-            "glob": "README.md",
-            "input": ".",
-            "output": "."
-          }
-        ],
-        "format": ["esm", "cjs"],
-        "compiler": "tsc",
-        "rollupConfig": "tools/scripts/rollup.config.js",
-        "generateExportsField": true,
-        "updateBuildableProjectDepsInPackageJson": true
-      }
-    },
-    "lint": {
-      "executor": "@nx/eslint:lint",
-      "outputs": ["{options.outputFile}"],
-      "options": {
-        "lintFilePatterns": ["libs/ts-rest/core/**/*.ts"]
-      }
-    },
-    "test": {
-      "executor": "@nx/jest:jest",
-      "outputs": ["{workspaceRoot}/coverage/libs/ts-rest/core"],
-      "options": {
-        "jestConfig": "libs/ts-rest/core/jest.config.ts",
-        "coverageReporters": ["lcov", "text-summary"]
-      }
-    }
-  },
-  "tags": []
-}