New Case Study:See how Anthropic automated 95% of dependency reviews with Socket.Learn More →
Socket
Sign inDemoInstall
Socket
Sign inDemoInstall

@orpc/contract

Package Overview
Dependencies
Maintainers
0
Versions
229
Alerts
File Explorer

Advanced tools

License
Socket logo

Install Socket

Detect and block malicious and high-risk dependencies

Install

@orpc/contract - npm Package Compare versions

Comparing version 0.40.0 to 0.41.0

258

dist/index.js

@@ -1,2 +0,9 @@

// src/error-map.ts
// src/error.ts
var ValidationError = class extends Error {
issues;
constructor(options) {
super(options.message, options);
this.issues = options.issues;
}
};
function mergeErrorMap(errorMap1, errorMap2) {

@@ -163,192 +170,2 @@ return { ...errorMap1, ...errorMap2 };

// src/error-orpc.ts
import { isObject } from "@orpc/shared";
var COMMON_ORPC_ERROR_DEFS = {
BAD_REQUEST: {
status: 400,
message: "Bad Request"
},
UNAUTHORIZED: {
status: 401,
message: "Unauthorized"
},
FORBIDDEN: {
status: 403,
message: "Forbidden"
},
NOT_FOUND: {
status: 404,
message: "Not Found"
},
METHOD_NOT_SUPPORTED: {
status: 405,
message: "Method Not Supported"
},
NOT_ACCEPTABLE: {
status: 406,
message: "Not Acceptable"
},
TIMEOUT: {
status: 408,
message: "Request Timeout"
},
CONFLICT: {
status: 409,
message: "Conflict"
},
PRECONDITION_FAILED: {
status: 412,
message: "Precondition Failed"
},
PAYLOAD_TOO_LARGE: {
status: 413,
message: "Payload Too Large"
},
UNSUPPORTED_MEDIA_TYPE: {
status: 415,
message: "Unsupported Media Type"
},
UNPROCESSABLE_CONTENT: {
status: 422,
message: "Unprocessable Content"
},
TOO_MANY_REQUESTS: {
status: 429,
message: "Too Many Requests"
},
CLIENT_CLOSED_REQUEST: {
status: 499,
message: "Client Closed Request"
},
INTERNAL_SERVER_ERROR: {
status: 500,
message: "Internal Server Error"
},
NOT_IMPLEMENTED: {
status: 501,
message: "Not Implemented"
},
BAD_GATEWAY: {
status: 502,
message: "Bad Gateway"
},
SERVICE_UNAVAILABLE: {
status: 503,
message: "Service Unavailable"
},
GATEWAY_TIMEOUT: {
status: 504,
message: "Gateway Timeout"
}
};
function fallbackORPCErrorStatus(code, status) {
return status ?? COMMON_ORPC_ERROR_DEFS[code]?.status ?? 500;
}
function fallbackORPCErrorMessage(code, message) {
return message || COMMON_ORPC_ERROR_DEFS[code]?.message || code;
}
var ORPCError = class _ORPCError extends Error {
defined;
code;
status;
data;
constructor(code, ...[options]) {
if (options?.status && (options.status < 400 || options.status >= 600)) {
throw new Error("[ORPCError] The error status code must be in the 400-599 range.");
}
const message = fallbackORPCErrorMessage(code, options?.message);
super(message, options);
this.code = code;
this.status = fallbackORPCErrorStatus(code, options?.status);
this.defined = options?.defined ?? false;
this.data = options?.data;
}
toJSON() {
return {
defined: this.defined,
code: this.code,
status: this.status,
message: this.message,
data: this.data
};
}
static fromJSON(json, options) {
return new _ORPCError(json.code, {
...options,
...json
});
}
static isValidJSON(json) {
if (!isObject(json)) {
return false;
}
const validKeys = ["defined", "code", "status", "message", "data"];
if (Object.keys(json).some((k) => !validKeys.includes(k))) {
return false;
}
return "defined" in json && typeof json.defined === "boolean" && "code" in json && typeof json.code === "string" && "status" in json && typeof json.status === "number" && "message" in json && typeof json.message === "string";
}
};
// src/error-utils.ts
function isDefinedError(error) {
return error instanceof ORPCError && error.defined;
}
function createORPCErrorConstructorMap(errors) {
const proxy = new Proxy(errors, {
get(target, code) {
if (typeof code !== "string") {
return Reflect.get(target, code);
}
const item = (...[options]) => {
const config = errors[code];
return new ORPCError(code, {
defined: Boolean(config),
status: config?.status,
message: options?.message ?? config?.message,
data: options?.data,
cause: options?.cause
});
};
return item;
}
});
return proxy;
}
async function validateORPCError(map, error) {
const { code, status, message, data, cause, defined } = error;
const config = map?.[error.code];
if (!config || fallbackORPCErrorStatus(error.code, config.status) !== error.status) {
return defined ? new ORPCError(code, { defined: false, status, message, data, cause }) : error;
}
if (!config.data) {
return defined ? error : new ORPCError(code, { defined: true, status, message, data, cause });
}
const validated = await config.data["~standard"].validate(error.data);
if (validated.issues) {
return defined ? new ORPCError(code, { defined: false, status, message, data, cause }) : error;
}
return new ORPCError(code, { defined: true, status, message, data: validated.value, cause });
}
function toORPCError(error) {
return error instanceof ORPCError ? error : new ORPCError("INTERNAL_SERVER_ERROR", {
message: "Internal server error",
cause: error
});
}
// src/client-utils.ts
async function safe(promise) {
try {
const output = await promise;
return [output, void 0, false];
} catch (e) {
const error = e;
if (isDefinedError(error)) {
return [void 0, error, true];
}
return [void 0, error, false];
}
}
// src/config.ts

@@ -369,44 +186,5 @@ var DEFAULT_CONFIG = {

// src/error.ts
var ValidationError = class extends Error {
issues;
constructor(options) {
super(options.message, options);
this.issues = options.issues;
}
};
// src/event-iterator.ts
import { getEventMeta, isAsyncIteratorObject, isEventMetaContainer, withEventMeta } from "@orpc/server-standard";
function mapEventIterator(iterator, maps) {
return async function* () {
try {
while (true) {
const { done, value } = await iterator.next();
let mappedValue = await maps.value(value, done);
if (mappedValue !== value) {
const meta = getEventMeta(value);
if (meta && isEventMetaContainer(mappedValue)) {
mappedValue = withEventMeta(mappedValue, meta);
}
}
if (done) {
return mappedValue;
}
yield mappedValue;
}
} catch (error) {
let mappedError = await maps.error(error);
if (mappedError !== error) {
const meta = getEventMeta(error);
if (meta && isEventMetaContainer(mappedError)) {
mappedError = withEventMeta(mappedError, meta);
}
}
throw mappedError;
} finally {
await iterator.return?.();
}
}();
}
import { mapEventIterator, ORPCError } from "@orpc/client";
import { isAsyncIteratorObject } from "@orpc/server-standard";
var EVENT_ITERATOR_SCHEMA_SYMBOL = Symbol("ORPC_EVENT_ITERATOR_SCHEMA");

@@ -470,19 +248,16 @@ function eventIterator(yields, returns) {

}
// src/index.ts
import { ORPCError as ORPCError2 } from "@orpc/client";
export {
COMMON_ORPC_ERROR_DEFS,
ContractBuilder,
ContractProcedure,
ORPCError,
ORPCError2 as ORPCError,
ValidationError,
adaptContractRouter,
adaptRoute,
createORPCErrorConstructorMap,
eventIterator,
fallbackContractConfig,
fallbackORPCErrorMessage,
fallbackORPCErrorStatus,
getEventIteratorSchemaDetails,
isContractProcedure,
isDefinedError,
mapEventIterator,
mergeErrorMap,

@@ -495,8 +270,5 @@ mergeMeta,

prefixRoute,
safe,
toORPCError,
type,
unshiftTagRoute,
validateORPCError
unshiftTagRoute
};
//# sourceMappingURL=index.js.map

2

dist/src/builder-variants.d.ts

@@ -1,2 +0,2 @@

import type { ErrorMap, MergedErrorMap } from './error-map';
import type { ErrorMap, MergedErrorMap } from './error';
import type { Meta } from './meta';

@@ -3,0 +3,0 @@ import type { ContractProcedure } from './procedure';

2

dist/src/builder.d.ts

@@ -5,3 +5,3 @@ import type { ContractProcedureBuilder, ContractProcedureBuilderWithInput, ContractProcedureBuilderWithOutput, ContractRouterBuilder } from './builder-variants';

import type { Schema } from './schema';
import { type ErrorMap, type MergedErrorMap } from './error-map';
import { type ErrorMap, type MergedErrorMap } from './error';
import { type Meta } from './meta';

@@ -8,0 +8,0 @@ import { ContractProcedure } from './procedure';

20

dist/src/error.d.ts

@@ -0,5 +1,4 @@

import type { ORPCError, ORPCErrorCode } from '@orpc/client';
import type { StandardSchemaV1 } from '@standard-schema/spec';
import type { ErrorMap } from './error-map';
import type { ORPCErrorFromErrorMap } from './error-orpc';
export type ErrorFromErrorMap<TErrorMap extends ErrorMap> = Error | ORPCErrorFromErrorMap<TErrorMap>;
import type { Schema, SchemaOutput } from './schema';
export interface ValidationErrorOptions extends ErrorOptions {

@@ -13,2 +12,17 @@ message: string;

}
export type ErrorMapItem<TDataSchema extends Schema> = {
status?: number;
message?: string;
description?: string;
data?: TDataSchema;
};
export type ErrorMap = {
[key in ORPCErrorCode]?: ErrorMapItem<Schema>;
};
export type MergedErrorMap<T1 extends ErrorMap, T2 extends ErrorMap> = Omit<T1, keyof T2> & T2;
export declare function mergeErrorMap<T1 extends ErrorMap, T2 extends ErrorMap>(errorMap1: T1, errorMap2: T2): MergedErrorMap<T1, T2>;
export type ORPCErrorFromErrorMap<TErrorMap extends ErrorMap> = {
[K in keyof TErrorMap]: K extends string ? TErrorMap[K] extends ErrorMapItem<infer TDataSchema> ? ORPCError<K, SchemaOutput<TDataSchema>> : never : never;
}[keyof TErrorMap];
export type ErrorFromErrorMap<TErrorMap extends ErrorMap> = Error | ORPCErrorFromErrorMap<TErrorMap>;
//# sourceMappingURL=error.d.ts.map

4

dist/src/event-iterator.d.ts
import type { StandardSchemaV1 } from '@standard-schema/spec';
import type { Schema } from './schema';
export declare function mapEventIterator<TYield, TReturn, TNext, TMap = TYield | TReturn>(iterator: AsyncIterator<TYield, TReturn, TNext>, maps: {
value: (value: NoInfer<TYield | TReturn>, done: boolean | undefined) => Promise<TMap>;
error: (error: unknown) => Promise<unknown>;
}): AsyncGenerator<TMap, TMap, TNext>;
export declare function eventIterator<TYieldIn, TYieldOut, TReturnIn = unknown, TReturnOut = unknown>(yields: StandardSchemaV1<TYieldIn, TYieldOut>, returns?: StandardSchemaV1<TReturnIn, TReturnOut>): StandardSchemaV1<AsyncIteratorObject<TYieldIn, TReturnIn, void>, AsyncIteratorObject<TYieldOut, TReturnOut, void>>;

@@ -8,0 +4,0 @@ export declare function getEventIteratorSchemaDetails(schema: Schema): undefined | {

6

dist/src/index.d.ts
/** unnoq */
export * from './builder';
export * from './builder-variants';
export * from './client';
export * from './client-utils';
export * from './config';
export * from './error';
export * from './error-map';
export * from './error-orpc';
export * from './error-utils';
export * from './event-iterator';

@@ -19,2 +14,3 @@ export * from './meta';

export * from './schema';
export { ORPCError } from '@orpc/client';
//# sourceMappingURL=index.d.ts.map

5

dist/src/procedure-client.d.ts

@@ -1,6 +0,5 @@

import type { Client, ClientContext } from './client';
import type { ErrorFromErrorMap } from './error';
import type { ErrorMap } from './error-map';
import type { Client, ClientContext } from '@orpc/client';
import type { ErrorFromErrorMap, ErrorMap } from './error';
import type { Schema, SchemaInput, SchemaOutput } from './schema';
export type ContractProcedureClient<TClientContext extends ClientContext, TInputSchema extends Schema, TOutputSchema extends Schema, TErrorMap extends ErrorMap> = Client<TClientContext, SchemaInput<TInputSchema>, SchemaOutput<TOutputSchema>, ErrorFromErrorMap<TErrorMap>>;
//# sourceMappingURL=procedure-client.d.ts.map

2

dist/src/procedure.d.ts

@@ -1,2 +0,2 @@

import type { ErrorMap } from './error-map';
import type { ErrorMap } from './error';
import type { Meta } from './meta';

@@ -3,0 +3,0 @@ import type { Route } from './route';

4

dist/src/router-client.d.ts

@@ -1,8 +0,8 @@

import type { ClientContext } from './client';
import type { ClientContext } from '@orpc/client';
import type { ContractProcedure } from './procedure';
import type { ContractProcedureClient } from './procedure-client';
import type { AnyContractRouter } from './router';
export type ContractRouterClient<TRouter extends AnyContractRouter, TClientContext extends ClientContext> = TRouter extends ContractProcedure<infer UInputSchema, infer UOutputSchema, infer UErrorMap, any> ? ContractProcedureClient<TClientContext, UInputSchema, UOutputSchema, UErrorMap> : {
export type ContractRouterClient<TRouter extends AnyContractRouter, TClientContext extends ClientContext = Record<never, never>> = TRouter extends ContractProcedure<infer UInputSchema, infer UOutputSchema, infer UErrorMap, any> ? ContractProcedureClient<TClientContext, UInputSchema, UOutputSchema, UErrorMap> : {
[K in keyof TRouter]: TRouter[K] extends AnyContractRouter ? ContractRouterClient<TRouter[K], TClientContext> : never;
};
//# sourceMappingURL=router-client.d.ts.map

2

dist/src/router.d.ts
import type { Meta } from './meta';
import type { SchemaInput, SchemaOutput } from './schema';
import { type ErrorMap, type MergedErrorMap } from './error-map';
import { type ErrorMap, type MergedErrorMap } from './error';
import { ContractProcedure } from './procedure';

@@ -5,0 +5,0 @@ import { type HTTPPath } from './route';

5

package.json
{
"name": "@orpc/contract",
"type": "module",
"version": "0.40.0",
"version": "0.41.0",
"license": "MIT",

@@ -34,3 +34,4 @@ "homepage": "https://orpc.unnoq.com",

"@standard-schema/spec": "^1.0.0",
"@orpc/shared": "0.40.0"
"@orpc/client": "0.41.0",
"@orpc/shared": "0.41.0"
},

@@ -37,0 +38,0 @@ "devDependencies": {

dist/src/client-utils.d.ts
dist/src/client.d.ts
dist/src/error-map.d.ts
dist/src/error-orpc.d.ts
dist/src/error-utils.d.ts
SocketSocket SOC 2 Logo

Product

  • Package Alerts
  • Integrations
  • Docs
  • Pricing
  • FAQ
  • Roadmap
  • Changelog

About

Packages

npm

Go

Maven

PyPI

Rubygems

Stay in touch

Get open source security insights delivered straight into your inbox.

  • Terms
  • Privacy
  • Security

Made with ⚡️ by Socket Inc