@rsdk/grpc.server 4.0.0-next.4 → 4.0.0-next.6

package/src/reflection.service.spec.ts

@@ -0,0 +1,86 @@
+import { FileDescriptorProto } from '@bufbuild/protobuf';
+import type { PlatformTestingModule } from '@rsdk/testing';
+import { PlatformTest } from '@rsdk/testing';
+
+import { ReflectionService } from './reflection.service';
+
+describe('ReflectionService', () => {
+  let testingModule: PlatformTestingModule;
+  let reflectionService: ReflectionService;
+
+  beforeAll(async () => {
+    const platformTesting = await PlatformTest.create({});
+
+    testingModule = await platformTesting
+      .createTestingModule({
+        providers: [
+          ReflectionService,
+          {
+            provide: 'GRPC_PACKAGES',
+            useValue: [],
+          },
+        ],
+      })
+      .compile();
+
+    reflectionService = testingModule.get(ReflectionService);
+
+    reflectionService.onModuleInit();
+  });
+
+  afterAll(async () => {
+    await testingModule.close();
+  });
+
+  describe('listServices()', () => {
+    it('lists all services', () => {
+      const services = reflectionService.listServices();
+
+      expect(services).toHaveLength(4);
+      expect(services).toContain('grpc.health.v1.Health');
+      expect(services).toContain('grpc.metrics.v1.Metrics');
+      expect(services).toContain('grpc.reflection.v1.ServerReflection');
+      expect(services).toContain('grpc.reflection.v1alpha.ServerReflection');
+    });
+  });
+
+  describe('fileByFilename()', () => {
+    it('finds files with no transitive dependencies', () => {
+      const descriptor = FileDescriptorProto.fromBinary(
+        reflectionService.fileByName('grpc/health/v1/health.proto'),
+      );
+
+      expect(descriptor.name).toEqual('grpc/health/v1/health.proto');
+    });
+
+    it('errors with no file found', () => {
+      expect(() => reflectionService.fileByName('nonexistent.proto')).toThrow(
+        'file: nonexistent.proto not found',
+      );
+    });
+  });
+
+  describe('fileContainingSymbol()', () => {
+    it('finds symbols and returns transitive file dependencies', () => {
+      const descriptor = FileDescriptorProto.fromBinary(
+        reflectionService.fileBySymbol('grpc.health.v1.HealthCheckRequest'),
+      );
+
+      expect(descriptor.name).toEqual('grpc/health/v1/health.proto');
+    });
+
+    it('resolves references to method types', () => {
+      const descriptor = FileDescriptorProto.fromBinary(
+        reflectionService.fileBySymbol('grpc.health.v1.Health.Check'),
+      );
+
+      expect(descriptor.name).toEqual('grpc/health/v1/health.proto');
+    });
+
+    it('errors with no symbol found', () => {
+      expect(() =>
+        reflectionService.fileBySymbol('non.existant.symbol'),
+      ).toThrow('symbol: non.existant.symbol not found');
+    });
+  });
+});

package/src/reflection.service.ts

@@ -0,0 +1,210 @@
+import type {
+  EnumDescriptorProto,
+  MethodDescriptorProto,
+} from '@bufbuild/protobuf';
+import {
+  DescriptorProto,
+  FileDescriptorProto,
+  FileDescriptorSet,
+  ServiceDescriptorProto,
+} from '@bufbuild/protobuf';
+import type { OnModuleInit } from '@nestjs/common';
+import { Inject, Injectable } from '@nestjs/common';
+import HealthGrpcPackage from '@rsdk/builtin-contract/dist/grpc.health.v1';
+import MetricsGrpcPackage from '@rsdk/builtin-contract/dist/grpc.metrics.v1';
+import ReflectionGrpcPackageV1 from '@rsdk/builtin-contract/dist/grpc.reflection.v1';
+import ReflectionGrpcPackageV1alpha from '@rsdk/builtin-contract/dist/grpc.reflection.v1alpha';
+import type { Package } from '@rsdk/grpc.loader';
+import { LoggerFactory } from '@rsdk/logging';
+
+@Injectable()
+export class ReflectionService implements OnModuleInit {
+  private readonly services: Set<string> = new Set();
+  private readonly files: FileDescriptorProto[] = [];
+  private readonly logger = LoggerFactory.create(ReflectionService);
+
+  constructor(@Inject('GRPC_PACKAGES') private readonly packages: Package[]) {}
+
+  onModuleInit(): void {
+    const allPackages = [
+      ...this.packages,
+      HealthGrpcPackage,
+      MetricsGrpcPackage,
+      ReflectionGrpcPackageV1,
+      ReflectionGrpcPackageV1alpha,
+    ];
+
+    const allPackagesNames = new Set(allPackages.map((pkg) => pkg.name));
+
+    for (const pkg of allPackages) {
+      if (pkg.descriptor) {
+        for (const service of Object.keys(pkg.definitions['grpc-js'])) {
+          this.logger.info(
+            `GRPC descriptor loaded for service: ${pkg.name}.${service}`,
+          );
+        }
+
+        for (const file of FileDescriptorSet.fromBinary(pkg.descriptor).file) {
+          this.files.push(file);
+
+          if (allPackagesNames.has(`${file.package}`)) {
+            for (const service of file.service) {
+              this.services.add(`${file.package}.${service.name}`);
+            }
+          }
+        }
+      }
+    }
+  }
+
+  /**
+   * List the full names of registered gRPC services
+   *
+   * note: the spec is unclear as to what the 'listServices' param can be; most
+   * clients seem to only pass '*' but unsure if this should behave like a
+   * filter. Until we know how this should behave with different inputs this
+   * just always returns *all* services.
+   *
+   * @returns full-qualified service names (eg. 'sample.SampleService')
+   */
+  listServices(): string[] {
+    return [...this.services];
+  }
+
+  /**
+   * Find the proto file(s) that declares the given fully-qualified symbol name
+   *
+   * @param symbol fully-qualified name of the symbol to lookup
+   * (e.g. package.service[.method] or package.type)
+   *
+   * @returns descriptors of the file which contains this symbol and its imports
+   */
+  fileBySymbol(symbol: string): Buffer {
+    const file = this.files.find((file) => this.findSymbol(symbol, file));
+
+    if (file) {
+      return Buffer.from(file.toBinary());
+    }
+
+    throw new Error(`symbol: ${symbol} not found`);
+  }
+
+  /**
+   * Find a proto file by the file name
+   * @returns descriptors of the file which contains this symbol and its imports
+   */
+  fileByName(filename: string): Buffer {
+    const file = this.files.find((file) => file.name === filename);
+
+    if (file) {
+      return Buffer.from(file.toBinary());
+    }
+
+    throw new Error(`file: ${filename} not found`);
+  }
+
+  /**
+   * Find a proto file containing an extension to a message type
+   * @returns descriptors of the file which contains this symbol and its imports
+   */
+  fileContainingExtension(
+    containingType: string,
+    extensionNumber: number,
+  ): Buffer {
+    const extension = this.files.find((file) => {
+      const descriptor = this.findSymbol(containingType, file);
+
+      return (
+        descriptor instanceof DescriptorProto &&
+        descriptor.extension.some(
+          (extension) => extensionNumber === extension.number,
+        )
+      );
+    });
+
+    if (extension) {
+      return Buffer.from(extension.toBinary());
+    }
+
+    throw new Error(
+      `containingType: ${containingType}, extensionNumber: ${extensionNumber} not found`,
+    );
+  }
+
+  allExtensionNumbersOfType(symbol: string): number[] {
+    return [
+      ...new Set(
+        this.files.flatMap((file) =>
+          file.extension.flatMap((_fqn, _file, ext) =>
+            ext
+              .filter((e) => e.extendee === symbol)
+              .flatMap((e) => Number(e.number)),
+          ),
+        ),
+      ),
+    ];
+  }
+
+  private findSymbol(
+    symbol: string,
+    descriptor:
+      | FileDescriptorProto
+      | DescriptorProto
+      | EnumDescriptorProto
+      | ServiceDescriptorProto
+      | MethodDescriptorProto,
+    prefix = '',
+  ):
+    | DescriptorProto
+    | EnumDescriptorProto
+    | ServiceDescriptorProto
+    | MethodDescriptorProto
+    | undefined {
+    if (descriptor instanceof FileDescriptorProto) {
+      const packageName = descriptor.package;
+
+      const packagePrefix = packageName ? `${packageName}.` : '';
+
+      return (
+        descriptor.messageType.find((type) =>
+          this.findSymbol(symbol, type, packagePrefix),
+        ) ??
+        descriptor.enumType.find((type) =>
+          this.findSymbol(symbol, type, packagePrefix),
+        ) ??
+        descriptor.service.find((type) =>
+          this.findSymbol(symbol, type, packagePrefix),
+        )
+      );
+    }
+
+    const fullName = prefix + descriptor.name;
+
+    if (symbol === fullName) {
+      return descriptor;
+    }
+
+    if (descriptor instanceof DescriptorProto) {
+      const messagePrefix = `${fullName}.`;
+
+      return (
+        descriptor.nestedType.find((type) =>
+          this.findSymbol(symbol, type, messagePrefix),
+        ) ??
+        descriptor.enumType.find((type) =>
+          this.findSymbol(symbol, type, messagePrefix),
+        )
+      );
+    }
+
+    if (descriptor instanceof ServiceDescriptorProto) {
+      const servicePrefix = `${fullName}.`;
+
+      return descriptor.method.find((method) =>
+        this.findSymbol(symbol, method, servicePrefix),
+      );
+    }
+
+    return undefined;
+  }
+}