@atls/nestjs-connectrpc 0.0.1

package/README.md

@@ -0,0 +1 @@
+ConnectRpc migration @wolfcoded/nestjs-bufconnect

package/dist/connectrpc.constants.d.ts

@@ -0,0 +1,3 @@
+export declare const METHOD_DECORATOR_KEY: unique symbol;
+export declare const STREAM_METHOD_DECORATOR_KEY: unique symbol;
+export declare const CONNECTRPC_TRANSPORT: unique symbol;

package/dist/connectrpc.constants.js

@@ -0,0 +1,3 @@
+export const METHOD_DECORATOR_KEY = Symbol('METHOD_DECORATOR_KEY');
+export const STREAM_METHOD_DECORATOR_KEY = Symbol('STREAM_METHOD_DECORATOR_KEY');
+export const CONNECTRPC_TRANSPORT = Symbol('CONNECTRPC_TRANSPORT');

package/dist/connectrpc.decorators.d.ts

@@ -0,0 +1,6 @@
+import type { ServiceType } from '@bufbuild/protobuf';
+import { MethodType } from './connectrpc.interfaces.js';
+export declare const ConnectRpcService: (serviceName: ServiceType) => ClassDecorator;
+export declare const AddMethodMetadata: (target: object, key: string | symbol, methodType: MethodType, metadataKey: string | symbol) => void;
+export declare const ConnectRpcMethod: () => MethodDecorator;
+export declare const ConnectRpcStreamMethod: () => MethodDecorator;

package/dist/connectrpc.decorators.js

@@ -0,0 +1,41 @@
+import { MessagePattern } from '@nestjs/microservices';
+import { CONNECTRPC_TRANSPORT } from './connectrpc.constants.js';
+import { METHOD_DECORATOR_KEY } from './connectrpc.constants.js';
+import { STREAM_METHOD_DECORATOR_KEY } from './connectrpc.constants.js';
+import { MethodType } from './connectrpc.interfaces.js';
+import { CustomMetadataStore } from './custom-metadata.storage.js';
+import { createConnectRpcMethodMetadata } from './utils/router.utils.js';
+function isFunctionPropertyDescriptor(descriptor) {
+    return descriptor !== undefined && typeof descriptor.value === 'function';
+}
+export const ConnectRpcService = (serviceName) => (target) => {
+    const unaryMethodKeys = Reflect.getMetadata(METHOD_DECORATOR_KEY, target) || [];
+    const streamMethodKeys = Reflect.getMetadata(STREAM_METHOD_DECORATOR_KEY, target) || [];
+    const allMethodKeys = [...unaryMethodKeys, ...streamMethodKeys];
+    allMethodKeys.forEach((methodImpl) => {
+        const { key: functionName, methodType } = methodImpl;
+        const descriptor = Object.getOwnPropertyDescriptor(target.prototype, functionName);
+        if (!descriptor || !isFunctionPropertyDescriptor(descriptor))
+            return;
+        const metadata = createConnectRpcMethodMetadata(descriptor.value, functionName, serviceName.typeName, functionName, methodType);
+        CustomMetadataStore.getInstance().set(serviceName.typeName, serviceName);
+        MessagePattern(metadata, CONNECTRPC_TRANSPORT)(target.prototype, functionName, descriptor);
+    });
+};
+export const AddMethodMetadata = (target, key, methodType, metadataKey) => {
+    const metadata = {
+        key: key.toString(),
+        methodType,
+    };
+    const existingMethods = Reflect.getMetadata(metadataKey, target.constructor) || new Set();
+    if (existingMethods.has(metadata))
+        return;
+    existingMethods.add(metadata);
+    Reflect.defineMetadata(metadataKey, existingMethods, target.constructor);
+};
+export const ConnectRpcMethod = () => (target, key) => {
+    AddMethodMetadata(target, key, MethodType.NO_STREAMING, METHOD_DECORATOR_KEY);
+};
+export const ConnectRpcStreamMethod = () => (target, key) => {
+    AddMethodMetadata(target, key, MethodType.RX_STREAMING, STREAM_METHOD_DECORATOR_KEY);
+};

package/dist/connectrpc.interfaces.d.ts

@@ -0,0 +1,59 @@
+import type * as http from 'http';
+import type * as http2 from 'http2';
+import type * as https from 'https';
+import type { ConnectRouterOptions } from '@connectrpc/connect';
+import type { Observable } from 'rxjs';
+export interface ConnectRpcPattern {
+    service: string;
+    rpc: string;
+    streaming: MethodType;
+}
+export declare enum MethodType {
+    NO_STREAMING = "no_stream",
+    RX_STREAMING = "rx_stream"
+}
+export declare enum ServerProtocol {
+    HTTP = "http",
+    HTTPS = "https",
+    HTTP2_INSECURE = "http2_insecure",
+    HTTP2 = "http2"
+}
+export interface BaseServerOptions {
+    port: number;
+    connectOptions?: ConnectRouterOptions;
+    callback?: () => void;
+}
+export interface HttpOptions extends BaseServerOptions {
+    protocol: ServerProtocol.HTTP;
+    serverOptions?: http.ServerOptions;
+}
+export interface HttpsOptions extends BaseServerOptions {
+    protocol: ServerProtocol.HTTPS;
+    serverOptions: https.ServerOptions;
+}
+export interface Http2Options extends BaseServerOptions {
+    protocol: ServerProtocol.HTTP2;
+    serverOptions: http2.SecureServerOptions;
+}
+export interface Http2InsecureOptions extends BaseServerOptions {
+    protocol: ServerProtocol.HTTP2_INSECURE;
+    serverOptions?: http2.ServerOptions;
+}
+export type ServerTypeOptions = Http2InsecureOptions | Http2Options | HttpOptions | HttpsOptions;
+export type ServerInstance = http.Server | http2.Http2Server | https.Server | null;
+export interface ConstructorWithPrototype {
+    prototype: Record<string, PropertyDescriptor>;
+}
+export interface MethodKey {
+    key: string;
+    methodType: MethodType;
+}
+export type MethodKeys = Array<MethodKey>;
+export interface FunctionPropertyDescriptor extends PropertyDescriptor {
+    value: (...arguments_: Array<never>) => never;
+}
+export type ResultOrDeferred<T> = Observable<T> | T | {
+    subscribe: () => void;
+} | {
+    toPromise: () => Promise<T>;
+};

package/dist/connectrpc.interfaces.js

@@ -0,0 +1,12 @@
+export var MethodType;
+(function (MethodType) {
+    MethodType["NO_STREAMING"] = "no_stream";
+    MethodType["RX_STREAMING"] = "rx_stream";
+})(MethodType || (MethodType = {}));
+export var ServerProtocol;
+(function (ServerProtocol) {
+    ServerProtocol["HTTP"] = "http";
+    ServerProtocol["HTTPS"] = "https";
+    ServerProtocol["HTTP2_INSECURE"] = "http2_insecure";
+    ServerProtocol["HTTP2"] = "http2";
+})(ServerProtocol || (ServerProtocol = {}));

package/dist/connectrpc.server.d.ts

@@ -0,0 +1,20 @@
+import type { ConnectRouter } from '@connectrpc/connect';
+import type { ServerTypeOptions } from './connectrpc.interfaces.js';
+import * as http from 'http';
+import * as http2 from 'http2';
+import * as https from 'https';
+export declare class HTTPServer {
+    private readonly options;
+    private readonly router;
+    private serverPrivate;
+    constructor(options: ServerTypeOptions, router: (router: ConnectRouter) => void);
+    set server(value: http.Server | http2.Http2Server | https.Server | null);
+    get server(): http.Server | http2.Http2Server | https.Server | null;
+    listen(): Promise<void>;
+    createHttpServer(): http.Server;
+    createHttpsServer(): https.Server;
+    createHttp2Server(): http2.Http2Server;
+    createHttp2InsecureServer(): http2.Http2Server;
+    startServer(): Promise<void>;
+    close(callback?: () => void): Promise<void>;
+}

package/dist/connectrpc.server.js

@@ -0,0 +1,88 @@
+import { connectNodeAdapter } from '@connectrpc/connect-node';
+import * as http from 'http';
+import * as http2 from 'http2';
+import * as https from 'https';
+import { ServerProtocol } from './connectrpc.interfaces.js';
+export class HTTPServer {
+    options;
+    router;
+    serverPrivate = null;
+    constructor(options, router) {
+        this.options = options;
+        this.router = router;
+    }
+    set server(value) {
+        this.serverPrivate = value;
+    }
+    get server() {
+        return this.serverPrivate;
+    }
+    async listen() {
+        await this.startServer();
+    }
+    createHttpServer() {
+        const { serverOptions = {}, connectOptions = {} } = this.options;
+        return http.createServer(serverOptions, connectNodeAdapter({
+            ...connectOptions,
+            routes: this.router,
+        }));
+    }
+    createHttpsServer() {
+        const { serverOptions = {}, connectOptions = {} } = this.options;
+        return https.createServer(serverOptions, connectNodeAdapter({ ...connectOptions, routes: this.router }));
+    }
+    createHttp2Server() {
+        const { serverOptions = {}, connectOptions = {} } = this.options;
+        return http2.createSecureServer(serverOptions, connectNodeAdapter({ ...connectOptions, routes: this.router }));
+    }
+    createHttp2InsecureServer() {
+        const { serverOptions = {}, connectOptions = {} } = this.options;
+        return http2.createServer(serverOptions, connectNodeAdapter({ ...connectOptions, routes: this.router }));
+    }
+    startServer() {
+        return new Promise((resolve, reject) => {
+            switch (this.options.protocol) {
+                case ServerProtocol.HTTP: {
+                    this.server = this.createHttpServer();
+                    break;
+                }
+                case ServerProtocol.HTTPS: {
+                    this.server = this.createHttpsServer();
+                    break;
+                }
+                case ServerProtocol.HTTP2: {
+                    this.server = this.createHttp2Server();
+                    break;
+                }
+                case ServerProtocol.HTTP2_INSECURE: {
+                    this.server = this.createHttp2InsecureServer();
+                    break;
+                }
+                default: {
+                    reject(new Error('Invalid protocol option'));
+                    return;
+                }
+            }
+            this.server.listen(this.options.port, () => {
+                if (this.options.callback)
+                    this.options.callback();
+                resolve();
+            });
+        });
+    }
+    async close(callback) {
+        return new Promise((resolve, reject) => {
+            if (this.server === null) {
+                reject(new Error('Server is not running'));
+            }
+            else {
+                this.server.close(() => {
+                    this.server = null;
+                    if (callback)
+                        callback();
+                    resolve();
+                });
+            }
+        });
+    }
+}

package/dist/connectrpc.strategy.d.ts

@@ -0,0 +1,15 @@
+import type { ConnectRouter } from '@connectrpc/connect';
+import type { CustomTransportStrategy } from '@nestjs/microservices';
+import type { MessageHandler } from '@nestjs/microservices';
+import type { ServerTypeOptions } from './connectrpc.interfaces.js';
+import { Server } from '@nestjs/microservices';
+export declare class ConnectRpcServer extends Server implements CustomTransportStrategy {
+    private readonly customMetadataStore;
+    private server;
+    private readonly options;
+    constructor(options: ServerTypeOptions);
+    listen(callback: (error?: unknown, ...optionalParameters: Array<unknown>) => void): Promise<void>;
+    close(): Promise<void>;
+    addHandler(pattern: unknown, callback: MessageHandler, isEventHandler?: boolean): void;
+    buildRouter(): (router: ConnectRouter) => void;
+}

package/dist/connectrpc.strategy.js

@@ -0,0 +1,48 @@
+import { Server } from '@nestjs/microservices';
+import { isString } from '@nestjs/common/utils/shared.utils.js';
+import { HTTPServer } from './connectrpc.server.js';
+import { CustomMetadataStore } from './custom-metadata.storage.js';
+import { addServicesToRouter } from './utils/router.utils.js';
+import { createServiceHandlersMap } from './utils/router.utils.js';
+export class ConnectRpcServer extends Server {
+    customMetadataStore = null;
+    server = null;
+    options;
+    constructor(options) {
+        super();
+        this.customMetadataStore = CustomMetadataStore.getInstance();
+        this.options = options;
+    }
+    async listen(callback) {
+        try {
+            const router = this.buildRouter();
+            this.server = new HTTPServer(this.options, router);
+            await this.server.listen();
+            callback();
+        }
+        catch (error) {
+            callback(error);
+        }
+    }
+    async close() {
+        await this.server?.close();
+    }
+    addHandler(pattern, callback, isEventHandler = false) {
+        const route = isString(pattern) ? pattern : JSON.stringify(pattern);
+        if (isEventHandler) {
+            const modifiedCallback = callback;
+            modifiedCallback.isEventHandler = true;
+            this.messageHandlers.set(route, modifiedCallback);
+            return;
+        }
+        this.messageHandlers.set(route, callback);
+    }
+    buildRouter() {
+        return (router) => {
+            if (!this.customMetadataStore)
+                return;
+            const serviceHandlersMap = createServiceHandlersMap(this.getHandlers(), this.customMetadataStore);
+            addServicesToRouter(router, serviceHandlersMap, this.customMetadataStore);
+        };
+    }
+}

package/dist/custom-metadata.storage.d.ts

@@ -0,0 +1,9 @@
+import type { ServiceType } from '@bufbuild/protobuf';
+export declare class CustomMetadataStore {
+    private static instance;
+    private customMetadata;
+    private constructor();
+    static getInstance(): CustomMetadataStore;
+    set(key: string, value: ServiceType): void;
+    get(key: string): ServiceType | undefined;
+}

package/dist/custom-metadata.storage.js

@@ -0,0 +1,17 @@
+export class CustomMetadataStore {
+    static instance;
+    customMetadata = new Map();
+    constructor() { }
+    static getInstance() {
+        if (!CustomMetadataStore.instance) {
+            CustomMetadataStore.instance = new CustomMetadataStore();
+        }
+        return CustomMetadataStore.instance;
+    }
+    set(key, value) {
+        this.customMetadata.set(key, value);
+    }
+    get(key) {
+        return this.customMetadata.get(key) ?? undefined;
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export * from './connectrpc.decorators.js';
+export * from './connectrpc.interfaces.js';
+export * from './connectrpc.strategy.js';
+export * from './connectrpc.server.js';

package/dist/index.js

@@ -0,0 +1,4 @@
+export * from "./connectrpc.decorators.js";
+export * from "./connectrpc.interfaces.js";
+export * from "./connectrpc.strategy.js";
+export * from "./connectrpc.server.js";

package/dist/utils/async.utils.d.ts

@@ -0,0 +1,13 @@
+import type { ResultOrDeferred } from '../connectrpc.interfaces.js';
+import { Observable } from 'rxjs';
+export declare function isAsyncGenerator<T>(input: unknown): input is AsyncGenerator<T>;
+export declare function observableToAsyncGenerator<T>(observable: Observable<T>): AsyncGenerator<T>;
+export declare const isObservable: <T>(object: unknown) => object is Observable<T>;
+export declare const hasSubscribe: (object: unknown) => object is {
+    subscribe: () => void;
+};
+export declare const hasToPromise: (object: unknown) => object is {
+    toPromise: () => Promise<unknown>;
+};
+export declare const transformToObservable: <T>(resultOrDeferred: ResultOrDeferred<T>) => Observable<T>;
+export declare function toAsyncGenerator<T>(input: AsyncGenerator<T> | Observable<T>): AsyncGenerator<T>;

package/dist/utils/async.utils.js

@@ -0,0 +1,95 @@
+import { Observable } from 'rxjs';
+import { Subject } from 'rxjs';
+import { from } from 'rxjs';
+import { lastValueFrom } from 'rxjs';
+export function isAsyncGenerator(input) {
+    return typeof input === 'object' && input !== null && Symbol.asyncIterator in input;
+}
+async function* asyncIterator(subject) {
+    const nextValue = async () => new Promise((resolve, reject) => {
+        subject.subscribe({
+            next: (val) => {
+                resolve(val);
+            },
+            error: (err) => {
+                reject(err);
+            },
+            complete: () => {
+                resolve(null);
+            },
+        });
+    });
+    while (true) {
+        const item = await nextValue();
+        if (item === null)
+            return;
+        yield item;
+    }
+}
+export async function* observableToAsyncGenerator(observable) {
+    const queue = new Subject();
+    const subscriber = observable.subscribe({
+        next: (value) => {
+            queue.next(value);
+        },
+        error: (error) => {
+            queue.error(error);
+        },
+        complete: () => {
+            queue.complete();
+        },
+    });
+    try {
+        for await (const item of asyncIterator(queue)) {
+            yield item;
+        }
+    }
+    finally {
+        subscriber.unsubscribe();
+    }
+}
+export const isObservable = (object) => object instanceof Observable;
+export const hasSubscribe = (object) => typeof object === 'object' &&
+    object !== null &&
+    typeof object.subscribe === 'function';
+export const hasToPromise = (object) => typeof object === 'object' &&
+    object !== null &&
+    typeof object.toPromise === 'function';
+export const transformToObservable = (resultOrDeferred) => {
+    if (isObservable(resultOrDeferred)) {
+        return resultOrDeferred;
+    }
+    if (hasSubscribe(resultOrDeferred)) {
+        return new Observable((subscriber) => {
+            resultOrDeferred.subscribe({
+                next: (value) => {
+                    subscriber.next(value);
+                },
+                error: (error) => {
+                    subscriber.error(error);
+                },
+                complete: () => {
+                    subscriber.complete();
+                },
+            });
+        });
+    }
+    if (hasToPromise(resultOrDeferred)) {
+        return from(lastValueFrom(resultOrDeferred));
+    }
+    return new Observable((subscriber) => {
+        subscriber.next(resultOrDeferred);
+        subscriber.complete();
+    });
+};
+export async function* toAsyncGenerator(input) {
+    if (isObservable(input)) {
+        yield* observableToAsyncGenerator(input);
+    }
+    else if (isAsyncGenerator(input)) {
+        yield* input;
+    }
+    else {
+        throw new TypeError('Unsupported input type. Expected an Observable or an AsyncGenerator.');
+    }
+}

package/dist/utils/router.utils.d.ts

@@ -0,0 +1,14 @@
+import type { ServiceType } from '@bufbuild/protobuf';
+import type { ConnectRouter } from '@connectrpc/connect';
+import type { ServiceImpl } from '@connectrpc/connect';
+import type { MessageHandler } from '@nestjs/microservices';
+import type { CustomMetadataStore } from '../custom-metadata.storage.js';
+import { MethodType } from '../connectrpc.interfaces.js';
+export declare const createPattern: (service: string, methodName: string, streaming: MethodType) => string;
+export declare const addServicesToRouter: (router: ConnectRouter, serviceHandlersMap: Record<string, Partial<ServiceImpl<ServiceType>>>, customMetadataStore: CustomMetadataStore) => void;
+export declare const createServiceHandlersMap: (handlers: Map<string, MessageHandler>, customMetadataStore: CustomMetadataStore) => Record<string, Partial<ServiceImpl<ServiceType>>>;
+export declare const createConnectRpcMethodMetadata: (target: object, key: string | symbol, service?: string, method?: string, streaming?: MethodType) => {
+    service: string;
+    rpc: string;
+    streaming: MethodType;
+};

package/dist/utils/router.utils.js

@@ -0,0 +1,50 @@
+import { lastValueFrom } from 'rxjs';
+import { MethodType } from '../connectrpc.interfaces.js';
+import { toAsyncGenerator } from './async.utils.js';
+import { transformToObservable } from './async.utils.js';
+export const createPattern = (service, methodName, streaming) => JSON.stringify({ service, rpc: methodName, streaming });
+export const addServicesToRouter = (router, serviceHandlersMap, customMetadataStore) => {
+    for (const serviceName of Object.keys(serviceHandlersMap)) {
+        const service = customMetadataStore.get(serviceName);
+        if (!service)
+            continue;
+        router.service(service, serviceHandlersMap[serviceName]);
+    }
+};
+export const createServiceHandlersMap = (handlers, customMetadataStore) => {
+    const serviceHandlersMap = {};
+    handlers.forEach((handlerMetadata, pattern) => {
+        const parsedPattern = JSON.parse(pattern);
+        const { service, rpc, streaming } = parsedPattern;
+        const serviceMetadata = customMetadataStore.get(service);
+        if (!serviceMetadata)
+            return;
+        const methodProto = serviceMetadata.methods[rpc];
+        if (!methodProto)
+            return;
+        serviceHandlersMap[service] ??= {};
+        switch (streaming) {
+            case MethodType.NO_STREAMING:
+                serviceHandlersMap[service][rpc] = async (request, context) => {
+                    const resultOrDeferred = await handlerMetadata(request, context);
+                    return lastValueFrom(transformToObservable(resultOrDeferred));
+                };
+                break;
+            case MethodType.RX_STREAMING:
+                serviceHandlersMap[service][rpc] = async function* handleStream(request, context) {
+                    const streamOrValue = await handlerMetadata(request, context);
+                    yield* toAsyncGenerator(streamOrValue);
+                };
+                break;
+            default:
+                throw new Error(`Unsupported streaming type: ${streaming}`);
+        }
+    });
+    return serviceHandlersMap;
+};
+export const createConnectRpcMethodMetadata = (target, key, service, method, streaming = MethodType.NO_STREAMING) => {
+    const capitalizeFirstLetter = (input) => input.charAt(0).toUpperCase() + input.slice(1);
+    const serviceName = service ?? target.constructor.name;
+    const rpcMethodName = method ?? capitalizeFirstLetter(String(key));
+    return { service: serviceName, rpc: rpcMethodName, streaming };
+};

package/package.json

@@ -0,0 +1,58 @@
+{
+  "name": "@atls/nestjs-connectrpc",
+  "version": "0.0.1",
+  "license": "BSD-3-Clause",
+  "type": "module",
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "main": "dist/index.js",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "yarn library build",
+    "prepack": "yarn run build",
+    "postpack": "rm -rf dist"
+  },
+  "devDependencies": {
+    "@bufbuild/protobuf": "1.10.0",
+    "@connectrpc/connect": "1.6.1",
+    "@connectrpc/connect-node": "1.6.1",
+    "@nestjs/common": "10.0.5",
+    "@nestjs/core": "10.0.5",
+    "@nestjs/microservices": "10.2.4",
+    "@nestjs/platform-express": "10.2.4",
+    "reflect-metadata": "0.2.2",
+    "rxjs": "7.8.1"
+  },
+  "peerDependencies": {
+    "@bufbuild/protobuf": "^1",
+    "@connectrpc/connect": "^1",
+    "@connectrpc/connect-node": "^1",
+    "@nestjs/common": "^10",
+    "@nestjs/core": "^10",
+    "@nestjs/microservices": "^10",
+    "@nestjs/platform-express": "^10",
+    "reflect-metadata": "^0.2",
+    "rxjs": "^7"
+  },
+  "publishConfig": {
+    "exports": {
+      "./package.json": "./package.json",
+      ".": {
+        "import": "./dist/index.js",
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      }
+    },
+    "main": "dist/index.js",
+    "typings": "dist/index.d.ts"
+  },
+  "typings": "dist/index.d.ts"
+}