@archtx/procedures 1.0.1

package/README.md

@@ -0,0 +1,283 @@
+# @archtx/procedures
+
+A **TypeScript** library for generating type-safe Procedure Calls with built-in schema validation using Suretype or TypeBox.
+
+## Features
+
+- Create type-safe Procedures
+- Built-in schema validation using Suretype/TypeBox
+- Runtime validation of arguments
+- Generated JSON-Schema for Procedures
+
+## Installation
+
+```bash
+npm install @archtx/procedures
+```
+
+## Usage
+
+### Basic Example
+
+```typescript
+import { Procedures } from '@archtx/procedures'
+import { v } from 'suretype'
+
+const { Create } = Procedures()
+
+// Register a query Procedure
+const { getUserInfo, getUserInfoSchema } = Create(
+  'getUserInfo',
+  {
+    schema: {
+      args: v.object({ userId: v.string().required() }),
+      data: v.object({
+        name: v.string().required(),
+        email: v.string(),
+      }),
+    },
+  },
+  async (ctx, args) => {
+    // Handle the Procedure call
+    return {
+      name: 'John Doe',
+      email: 'john@example.com',
+    }
+  },
+)
+
+// Call the Procedure
+const userInfo = await getUserInfo({ userId: '123' })
+
+// view the JSON-schema for the Procedure
+console.log(getUserInfoSchema.args, getUserInfoSchema.data)
+```
+
+### With Custom Context
+
+You can pass a `type` to the `Procedures<Type>()` invokation to require custom context in all procedure calls. The
+`hook` function allows you to add local context to the Procedure call. This is useful for adding additional context
+to the Procedure call, such as authentication tokens or user information.
+
+The context type will be typed in the Procedure handler first argument `ctx`.
+
+When your procedure has a `hook` the return value of the `hook` function will be passed to the Procedure handler by
+extending the `ctx` object. This allows you to pass additional context to the Procedure handler.
+
+```typescript
+interface CustomContext {
+  authToken: string
+}
+
+const { Create } = Procedures<CustomContext>({
+  // Procedure handler registration callback
+  onCreate: ({ handler, name }) => {
+    httpRouter.post(`/Procedure/${name}`, async (req) => {
+      return handler({ authToken: req.headers.authorization }, req.body)
+    })
+  },
+})
+
+const { CheckIsAuthenticated } = Create(
+  'CheckIsAuthenticated',
+  {
+    hook: async (ctx, args) => {
+      if (validateAuthToken(ctx.authToken)) {
+        const user = await getUserFromToken(ctx.authToken)
+
+        return { user }
+      }
+
+      throw new Error('Invalid auth token')
+    },
+
+    schema: {
+      data: v.string(),
+    },
+  },
+  async (ctx, args) => {
+    // Access context in handler with type-safety
+    console.log(ctx.user)
+    return 'User authentication is valid'
+  },
+)
+
+// Call the Procedure
+CheckIsAuthenticated({ authToken: 'valid-token' }, {}) // Returns 'User authentication is valid'
+CheckIsAuthenticated({ authToken: 'no-token' }, {}) // Throws 'ProcedureContextError: Invalid auth token'
+```
+
+### Retrieving Registered Procedures
+
+```typescript
+const { Create, getProcedures } = Procedures()
+
+// Later in your code
+const registeredProcedures = getProcedures()
+const userInfoProcedure = registeredProcedures.get('getUserInfo')
+```
+
+### Generated JSON-Schema
+
+```typescript
+const { Create, getProcedures } = Procedures()
+
+const { getUserInfo, getUserInfoSchema } = Create(
+  'getUserInfo',
+  {
+    schema: {
+      args: v.object({ userId: v.string().required() }),
+      data: v.object({
+        name: v.string().required(),
+        email: v.string(),
+      }),
+    },
+  },
+  async (ctx, args) => {
+    // Handle the Procedure call
+    return {
+      name: 'John Doe',
+      email: '',
+    }
+  },
+)
+
+console.log(getUserInfoSchema) // { args: JSON-schema; data: JSON-schema }
+// or
+console.log(getProcedures().get('getUserInfo').config.schema) // { args: JSON-schema; data: JSON-schema }
+```
+
+### Procedure Errors
+
+The context provided to each procedure has a built-in `error` method that can be used to throw errors with a specific
+error code and message. This is useful for handling errors in a consistent way across all procedures.
+
+```typescript
+import { Procedures, ProcedureCodes } from '@archtx/procedures'
+
+const { Create } = Procedures()
+
+const { getUserInfo } = Create(
+  'getUserInfo',
+  {
+    //...
+  },
+  async (ctx, args) => {
+    if (!isSomeConditionPassing(args)) {
+      throw ctx.error(
+        ProcedureCodes.PRECONDITION_FAILED,
+        'Some condition failed',
+        {
+          // extra (optional) meta data for the error
+        },
+      )
+    }
+    return {
+      name: 'John Doe',
+      email: '',
+    }
+  },
+)
+```
+
+The lib exports a `ProcedureError` that can be used:
+
+```typescript
+import { ProcedureError } from '@archtx/procedures'
+import { processError } from '@vitest/utils/error'
+
+const procedureError = new ProcedureError(500, 'Internal server error', {
+  // this 3rd argument is optional
+  extraInfo: '...',
+})
+
+processError.procedureName // string
+processError.code // number
+processError.message // string
+processError.meta // object
+```
+
+
+```
+/**
+ * A list of common codes borrowed from HTTP status codes.
+ */
+enum ProcedureCodes {
+  OK = 200,
+  CREATED = 201,
+  ACCEPTED = 202,
+  NO_CONTENT = 204,
+  RESET_CONTENT = 205,
+  PARTIAL_CONTENT = 206,
+  BAD_REQUEST = 400,
+  UNAUTHORIZED = 401,
+  FORBIDDEN = 403,
+  NOT_FOUND = 404,
+  NOT_ACCEPTABLE = 406,
+  PROXY_AUTHENTICATION_REQUIRED = 407,
+  TIMEOUT = 408,
+  CONFLICT = 409,
+  PRECONDITION_FAILED = 412,
+  VALIDATION_ERROR = 422,
+  TOO_MANY_REQUESTS = 429,
+  INTERNAL_ERROR = 500,
+  HANDLER_ERROR = 500,
+  NOT_IMPLEMENTED = 501,
+  SERVICE_UNAVAILABLE = 503,
+}
+```
+
+## API Reference
+
+### `Procedures(options?)`
+
+Creates a new Procedure generator instance.
+
+#### Options
+
+- `onCreate`: Callback function called when a new Procedure is registered
+  - `handler`: The Procedure handler function
+  - `config`: Configuration object containing schema and local Procedure context handler
+  - `name`: Name of the Procedure procedure
+
+### `Create`
+
+Object containing methods to register new Procedures.
+
+#### Methods
+
+- `query(name, options, handler)`: Register a query Procedure
+- `mutation(name, options, handler)`: Register a mutation Procedure
+
+> Note: `query` and `mutation` methods are identical, except for the type of Procedure registered.
+> These Procedure "type"'s are used in client implementation to differentiate between query and mutation Procedures.
+> This helps clients support caching calls appropriately if using a cache layer. For example, you can cache  
+> query Procedures but should not cache mutation Procedures.
+
+#### Options
+
+- `schema`:
+  - `args`: Suretype/TypeBox validation schema for arguments
+  - `data`: Suretype/TypeBox validation schema for return data
+- `context`: Function that returns additional context local to the Procedure call
+
+### Error Handling
+
+The library includes built-in validation error handling through the `ProcedureValidationError` class.
+
+If the Procedure `config.args` schema exists, the `args` are validated before the Procedure handler is called.
+If the validation fails, an `ProcedureValidationError` is thrown with the validation error message.
+
+## Acknowledgements
+
+- `@sinclair/typebox` - For providing a great library for generating JSON schema with TypeScript.
+- `@suretype/suretype` - For providing a great library for runtime type validation.
+- `@typeschema` - For providing inspiration for the Procedure schema resolver between Suretype or TypeBox.
+
+## License
+
+MIT
+
+## Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request.

package/dist/exports.d.ts

@@ -0,0 +1,6 @@
+export * from './src/index';
+export * from './src/errors';
+export * from './src/procedure-codes';
+export * from './src/schema/extract-json-schema';
+export * from './src/schema/parser';
+export * from './src/schema/resolve-schema-lib';

package/dist/exports.js

@@ -0,0 +1,7 @@
+export * from './src/index';
+export * from './src/errors';
+export * from './src/procedure-codes';
+export * from './src/schema/extract-json-schema';
+export * from './src/schema/parser';
+export * from './src/schema/resolve-schema-lib';
+//# sourceMappingURL=exports.js.map

package/dist/exports.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"exports.js","sourceRoot":"","sources":["../exports.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAA;AAC3B,cAAc,cAAc,CAAA;AAC5B,cAAc,uBAAuB,CAAA;AACrC,cAAc,kCAAkC,CAAA;AAChD,cAAc,qBAAqB,CAAA;AACnC,cAAc,iCAAiC,CAAA"}

package/dist/src/errors.d.ts

@@ -0,0 +1,22 @@
+import { TSchemaValidationError } from './schema/parser';
+import { ProcedureCodes } from './procedure-codes';
+export declare class ProcedureError extends Error {
+    readonly procedureName: string;
+    readonly code: ProcedureCodes & number;
+    readonly message: string;
+    readonly meta?: object | undefined;
+    constructor(procedureName: string, code: ProcedureCodes & number, message: string, meta?: object | undefined);
+}
+export declare class ProcedureHookError extends ProcedureError {
+    readonly procedureName: string;
+    constructor(procedureName: string, message: string);
+}
+export declare class ProcedureValidationError extends ProcedureError {
+    readonly procedureName: string;
+    readonly errors?: TSchemaValidationError[] | undefined;
+    constructor(procedureName: string, message: string, errors?: TSchemaValidationError[] | undefined);
+}
+export declare class ProcedureRegistrationError extends Error {
+    readonly procedureName: string;
+    constructor(procedureName: string, message: string);
+}

package/dist/src/errors.js

@@ -0,0 +1,50 @@
+import { ProcedureCodes } from './procedure-codes';
+export class ProcedureError extends Error {
+    procedureName;
+    code;
+    message;
+    meta;
+    constructor(procedureName, code, message, meta) {
+        super(message);
+        this.procedureName = procedureName;
+        this.code = code;
+        this.message = message;
+        this.meta = meta;
+        this.name = 'ProcedureError';
+        // https://www.dannyguo.com/blog/how-to-fix-instanceof-not-working-for-custom-errors-in-typescript/https://www.dannyguo.com/blog/how-to-fix-instanceof-not-working-for-custom-errors-in-typescript/
+        Object.setPrototypeOf(this, ProcedureError.prototype);
+    }
+}
+export class ProcedureHookError extends ProcedureError {
+    procedureName;
+    constructor(procedureName, message) {
+        super(procedureName, ProcedureCodes.PRECONDITION_FAILED, message);
+        this.procedureName = procedureName;
+        this.name = 'ProcedureHookError';
+        // https://www.dannyguo.com/blog/how-to-fix-instanceof-not-working-for-custom-errors-in-typescript/https://www.dannyguo.com/blog/how-to-fix-instanceof-not-working-for-custom-errors-in-typescript/
+        Object.setPrototypeOf(this, ProcedureHookError.prototype);
+    }
+}
+export class ProcedureValidationError extends ProcedureError {
+    procedureName;
+    errors;
+    constructor(procedureName, message, errors) {
+        super(procedureName, ProcedureCodes.VALIDATION_ERROR, message);
+        this.procedureName = procedureName;
+        this.errors = errors;
+        this.name = 'ProcedureValidationError';
+        // https://www.dannyguo.com/blog/how-to-fix-instanceof-not-working-for-custom-errors-in-typescript/https://www.dannyguo.com/blog/how-to-fix-instanceof-not-working-for-custom-errors-in-typescript/
+        Object.setPrototypeOf(this, ProcedureValidationError.prototype);
+    }
+}
+export class ProcedureRegistrationError extends Error {
+    procedureName;
+    constructor(procedureName, message) {
+        super(message);
+        this.procedureName = procedureName;
+        this.name = 'ProcedureRegistrationError';
+        // https://www.dannyguo.com/blog/how-to-fix-instanceof-not-working-for-custom-errors-in-typescript/https://www.dannyguo.com/blog/how-to-fix-instanceof-not-working-for-custom-errors-in-typescript/
+        Object.setPrototypeOf(this, ProcedureRegistrationError.prototype);
+    }
+}
+//# sourceMappingURL=errors.js.map

package/dist/src/errors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.js","sourceRoot":"","sources":["../../src/errors.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAA;AAElD,MAAM,OAAO,cAAe,SAAQ,KAAK;IAE5B;IACA;IACA;IACA;IAJX,YACW,aAAqB,EACrB,IAA6B,EAC7B,OAAe,EACf,IAAa;QAEtB,KAAK,CAAC,OAAO,CAAC,CAAA;QALL,kBAAa,GAAb,aAAa,CAAQ;QACrB,SAAI,GAAJ,IAAI,CAAyB;QAC7B,YAAO,GAAP,OAAO,CAAQ;QACf,SAAI,GAAJ,IAAI,CAAS;QAGtB,IAAI,CAAC,IAAI,GAAG,gBAAgB,CAAA;QAE5B,mMAAmM;QACnM,MAAM,CAAC,cAAc,CAAC,IAAI,EAAE,cAAc,CAAC,SAAS,CAAC,CAAA;IACvD,CAAC;CACF;AAED,MAAM,OAAO,kBAAmB,SAAQ,cAAc;IAEzC;IADX,YACW,aAAqB,EAC9B,OAAe;QAEf,KAAK,CAAC,aAAa,EAAE,cAAc,CAAC,mBAAmB,EAAE,OAAO,CAAC,CAAA;QAHxD,kBAAa,GAAb,aAAa,CAAQ;QAI9B,IAAI,CAAC,IAAI,GAAG,oBAAoB,CAAA;QAEhC,mMAAmM;QACnM,MAAM,CAAC,cAAc,CAAC,IAAI,EAAE,kBAAkB,CAAC,SAAS,CAAC,CAAA;IAC3D,CAAC;CACF;AAED,MAAM,OAAO,wBAAyB,SAAQ,cAAc;IAE/C;IAEA;IAHX,YACW,aAAqB,EAC9B,OAAe,EACN,MAAiC;QAE1C,KAAK,CAAC,aAAa,EAAE,cAAc,CAAC,gBAAgB,EAAE,OAAO,CAAC,CAAA;QAJrD,kBAAa,GAAb,aAAa,CAAQ;QAErB,WAAM,GAAN,MAAM,CAA2B;QAG1C,IAAI,CAAC,IAAI,GAAG,0BAA0B,CAAA;QAEtC,mMAAmM;QACnM,MAAM,CAAC,cAAc,CAAC,IAAI,EAAE,wBAAwB,CAAC,SAAS,CAAC,CAAA;IACjE,CAAC;CACF;AAED,MAAM,OAAO,0BAA2B,SAAQ,KAAK;IAC9B;IAArB,YAAqB,aAAqB,EAAE,OAAe;QACzD,KAAK,CAAC,OAAO,CAAC,CAAA;QADK,kBAAa,GAAb,aAAa,CAAQ;QAExC,IAAI,CAAC,IAAI,GAAG,4BAA4B,CAAA;QAExC,mMAAmM;QACnM,MAAM,CAAC,cAAc,CAAC,IAAI,EAAE,0BAA0B,CAAC,SAAS,CAAC,CAAA;IACnE,CAAC;CACF"}

package/dist/src/index.d.ts

@@ -0,0 +1,56 @@
+import { ProcedureError } from './errors';
+import { ProcedureCodes } from './procedure-codes';
+import { TJSONSchema, TSchemaLib } from './schema/types';
+export type TNoContextProvided = unknown;
+export type TLocalContext = {
+    error: (code: ProcedureCodes & number, message: string, meta?: object) => ProcedureError;
+};
+export declare function Procedures<TContext = TNoContextProvided>(
+/**
+ * Optionally provided builder to register Procedures
+ */
+builder?: {
+    onCreate?: (config: {
+        name: string;
+        config: {
+            hook?: (ctx: any, args?: any) => any;
+            schema?: {
+                args?: TJSONSchema;
+                data?: TJSONSchema;
+            };
+            validation?: {
+                args?: (args: any) => {
+                    errors?: any[];
+                };
+            };
+        };
+        handler: (ctx: any, args?: any) => Promise<any>;
+    }) => void;
+}): {
+    getProcedures: () => Map<string, {
+        name: string;
+        config: {
+            hook?: (ctx: any, args?: any) => any;
+            schema?: {
+                args?: TJSONSchema;
+                data?: TJSONSchema;
+            };
+            validation?: {
+                args?: (args: any) => {
+                    errors?: any[];
+                };
+            };
+        };
+        handler: (ctx: TContext, args: any) => Promise<any>;
+    }>;
+    Create: <TName extends string, TArgs, TData, TLocalHook>(name: TName, config: {
+        hook?: (ctx: TContext & TLocalContext, args: TSchemaLib<TArgs>) => Promise<TLocalHook>;
+        schema?: {
+            args?: TArgs;
+            data?: TData;
+        };
+    }, handler: (ctx: TContext & TLocalContext & TLocalHook, args: TSchemaLib<TArgs>) => Promise<TSchemaLib<TData>>) => { [K in TName | `${TName}Schema`]: K extends TName ? (ctx: TContext, args: TSchemaLib<TArgs>) => Promise<TSchemaLib<TData>> : {
+        args?: TSchemaLib<TArgs> extends unknown ? undefined : TJSONSchema;
+        data?: TSchemaLib<TData> extends unknown ? undefined : TJSONSchema;
+    }; };
+};

package/dist/src/index.js

@@ -0,0 +1,86 @@
+import { ProcedureHookError, ProcedureError, ProcedureValidationError, } from './errors';
+import { ProcedureCodes } from './procedure-codes';
+import { computeSchema } from './schema/compute-schema';
+export function Procedures(
+/**
+ * Optionally provided builder to register Procedures
+ */
+builder) {
+    const procedures = new Map();
+    function Create(name, config, handler) {
+        const { jsonSchema, validations } = computeSchema(name, config.schema);
+        const registeredProcedure = {
+            name,
+            config: {
+                ctx: config.hook,
+                schema: jsonSchema,
+                validation: {
+                    args: validations.args,
+                },
+            },
+            handler: async (ctx, args) => {
+                try {
+                    if (validations?.args) {
+                        const { errors } = validations.args(args);
+                        if (errors) {
+                            throw new ProcedureValidationError(name, `Validation error for ${name} - ${errors.map((e) => e.message).join(', ')}`, errors);
+                        }
+                    }
+                    const localCtx = {
+                        error: (code, message, meta) => {
+                            return new ProcedureError(name, code, message, meta);
+                        },
+                    };
+                    let computedLocalHook = {};
+                    if (config.hook) {
+                        try {
+                            computedLocalHook = (await config.hook({ ...localCtx, ...ctx }, args));
+                        }
+                        catch (error) {
+                            if (error instanceof ProcedureError) {
+                                throw error;
+                            }
+                            const err = new ProcedureHookError(name, `Error in hook for ${name} - ${error?.message}`);
+                            err.stack = error.stack;
+                            throw err;
+                        }
+                    }
+                    return handler({
+                        ...ctx,
+                        ...localCtx,
+                        ...computedLocalHook,
+                    }, args);
+                }
+                catch (error) {
+                    if (error instanceof ProcedureHookError) {
+                        throw error;
+                    }
+                    else if (error instanceof ProcedureError) {
+                        throw error;
+                    }
+                    else {
+                        const err = new ProcedureError(name, ProcedureCodes.HANDLER_ERROR, `Error in handler for ${name} - ${error?.message}`);
+                        err.stack = error.stack;
+                        throw err;
+                    }
+                }
+            },
+        };
+        procedures.set(name, registeredProcedure);
+        if (builder?.onCreate) {
+            builder.onCreate(registeredProcedure);
+        }
+        // return for testing so that the rpc can be called/tested individually or internally
+        return {
+            [name]: registeredProcedure.handler,
+            [`${name}Schema`]: jsonSchema,
+        };
+    }
+    return {
+        getProcedures: () => {
+            return procedures;
+        },
+        Create,
+    };
+}
+//# sourceMappingURL=index.js.map

package/dist/src/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"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"}

package/dist/src/index.test.d.ts

@@ -0,0 +1 @@
+export {};