feat(core): adds ensure static method to classes

packages/core/src/classes/Application/Application.ts

@@ -60,7 +60,7 @@ export class Application {
 
     const services: ApplicationServices = {};
 
-    new Collection(this.declaration).traverse((element, info, next) => {
+    Collection.ensure(this.declaration).traverse((element, info, next) => {
       next();
       if (isElementService(element)) {
         if (!info.route) throw Error(`Expected route on path: ${info.path}`);

packages/core/src/classes/Children.ts

@@ -20,6 +20,11 @@ export type ChildrenInput<A extends ChildrenServicesUnion> = Optional<
 export class Children<
   A extends ChildrenServicesUnion = ChildrenServicesUnion
 > extends Element<ChildrenUnion> {
+  public static ensure<A extends ChildrenServicesUnion = ChildrenServicesUnion>(
+    children: ChildrenUnion<A>
+  ): Children<A> {
+    return children instanceof Children ? children : new Children(children);
+  }
   public readonly schemas: ChildrenSchemasUnion;
   public readonly services: A;
   public constructor(children: ChildrenInput<A>) {

packages/core/src/classes/Collection/Collection.ts

@@ -48,6 +48,13 @@ export class Collection<
   D extends ServicesRecordUnion = {},
   E extends ScopesRecordUnion = {}
 > extends Element<CollectionTreeUnion> {
+  public static ensure<T extends CollectionTreeUnion>(
+    collection: T
+  ): CollectionInstance<T> {
+    return collection instanceof Collection
+      ? collection
+      : new Collection(collection);
+  }
   public static exceptions<T extends ExceptionsRecordUnion>(
     exceptions: T
   ): Collection<T, {}, {}, {}, {}> {

packages/core/src/classes/Exception.ts

@@ -14,6 +14,13 @@ export type ExceptionInput<L extends ExceptionLabel> = Optional<
 export class Exception<
   L extends ExceptionLabel = ExceptionLabel
 > extends Element<ExceptionUnion> {
+  public static ensure<L extends ExceptionLabel = ExceptionLabel>(
+    exception: ExceptionUnion<L>
+  ): Exception<L> {
+    return exception instanceof Exception
+      ? exception
+      : new Exception(exception);
+  }
   public readonly label: L;
   public readonly description: string | undefined;
   public constructor(exception: ExceptionInput<L>) {

packages/core/src/classes/Intercept/Intercept.ts

@@ -12,6 +12,13 @@ import { mergeServiceExceptions } from '~/transform/merge';
 export class Intercept<I = any, O = any, C = any> extends Element<
   InterceptImplementation
 > {
+  public static ensure<I = any, O = any, C = any>(
+    intercept: InterceptImplementation<I, O, C>
+  ): Intercept<I, O, C> {
+    return intercept instanceof Intercept
+      ? intercept
+      : new Intercept(intercept);
+  }
   /**
    * Exposes a simpler api to create intercepts to be run *before* the `resolve` function of a `ServiceImplementation` has been called to act on the incoming `data`.
    */

packages/core/src/classes/Schema.ts

@@ -9,6 +9,9 @@ export type SchemaConstructor = (
 export type SchemaInput = Optional<SchemaUnion, 'kind'>;
 
 export class Schema extends Element<SchemaUnion> {
+  static ensure(schema: SchemaUnion): Schema {
+    return schema instanceof Schema ? schema : new Schema(schema);
+  }
   static json(
     input?: SchemaInput | boolean | null,
     schema?: JSONSchema

packages/core/src/classes/Service/Service.ts

@@ -28,17 +28,26 @@ export class Service<
   O = any,
   C = any
 > extends Element<ServiceUnion> {
-  static query<T = void, I = any, O = any, C = any>(
+  public static ensure<
+    K extends ServiceKind = ServiceKind,
+    T = void,
+    I = any,
+    O = any,
+    C = any
+  >(service: ServiceInput<K, T, I, O, C>): Service<K, T, I, O, C> {
+    return service instanceof Service ? service : new Service(service as any);
+  }
+  public static query<T = void, I = any, O = any, C = any>(
     query?: ServiceQueryInput<T, I, O, C>
   ): Service<'query', T, I, O, C> {
     return new Service({ kind: 'query', ...query });
   }
-  static mutation<T = void, I = any, O = any, C = any>(
+  public static mutation<T = void, I = any, O = any, C = any>(
     mutation?: ServiceMutationInput<T, I, O, C>
   ): Service<'mutation', T, I, O, C> {
     return new Service({ kind: 'mutation', ...mutation });
   }
-  static subscription<T = void, I = any, O = any, C = any>(
+  public static subscription<T = void, I = any, O = any, C = any>(
     subscription?: ServiceSubscriptionInput<T, I, O, C>
   ): Service<'subscription', T, I, O, C> {
     return new Service({ kind: 'subscription', ...subscription });

packages/core/src/generate/client.ts

@@ -80,7 +80,7 @@ export async function client(
       };
 
   let content = '';
-  const instance = new Collection(await collection);
+  const instance = Collection.ensure(await collection);
 
   if (opts.typescript) {
     content += await typings(collection, {

packages/core/src/generate/typings.ts

@@ -29,7 +29,7 @@ export async function typings(
       '/* This file was automatically generated. DO NOT MODIFY IT BY HAND. */\n\n';
   }
 
-  const { schemas } = new Collection(await collection).lift();
+  const { schemas } = Collection.ensure(await collection).lift();
   for (const [key, value] of Object.entries(schemas)) {
     content += await compile(value.schema, key, { bannerComment: '' });
     content += '\n';

packages/rest/src/server/RESTServer.ts

@@ -26,7 +26,7 @@ export class RESTServer {
   ) {
     this.options = Object.assign(createDefaults(), options);
 
-    const instance = new Collection(collection);
+    const instance = Collection.ensure(collection);
     const app = new Application(
       this.options.subscriptions
         ? instance.toUnary()
@@ -37,6 +37,7 @@ export class RESTServer {
       options && options.fallback ? { fallback: options.fallback } : {}
     );
 
+    this.declaration = app.declaration;
     this.router = new ServerRouter(
       app.flatten('/'),
       app.fallback,
@@ -65,7 +66,7 @@ export class RESTServer {
       const item = mapError(err);
       const error = item
         ? item.error
-        : new Collection(this.declaration).error('ServerError', err, true);
+        : Collection.ensure(this.declaration).error('ServerError', err, true);
 
       return {
         status: item ? item.status : 500,

packages/rpc/src/reproduce.ts

@@ -40,7 +40,7 @@ export async function reproduce(
   );
 
   const implementation = Collection.merge(
-    new Collection(await collection).toImplementation((service, info) => {
+    Collection.ensure(await collection).toImplementation((service, info) => {
       if (isServiceQuery(service)) {
         return Service.query({
           ...service,