feat(gql/catalog): working on making the schema nice

2020-08-12 01:45:47 +02:00
parent 90579b9089
commit eb3ed5c0f8
5 changed files with 403 additions and 177 deletions
@@ -1,9 +1,7 @@
 overwrite: true
-schema: ./schema.gql
-require:
-  - ts-node/register/transpile-only
 generates:
  ./src/graphql/types.ts:
+    schema: ./src/schema.js
    plugins:
      - typescript
      - typescript-resolvers
@@ -11,6 +9,7 @@ generates:
      afterOneFileWrite:
        - eslint --fix
    config:
-      contextType: '@graphql-modules/core#ModuleContext'
+      contextType: "@graphql-modules/core#ModuleContext"
+      allowParentTypeOverride: true
      useIndexSignature: true
      defaultMapper: Partial<{T}>
@@ -27,7 +27,9 @@
    "@graphql-codegen/typescript": "^1.17.7",
    "@graphql-codegen/typescript-resolvers": "^1.17.7",
    "@graphql-modules/core": "^0.7.17",
+    "apollo-server": "^2.16.1",
    "graphql": "^15.3.0",
+    "graphql-tag": "^2.11.0",
    "graphql-type-json": "^0.3.2",
    "node-fetch": "^2.6.0",
    "ts-node": "^8.10.2",
@@ -1,62 +0,0 @@
-scalar JSON
-scalar JSONObject
-
-interface EntityMetadata {
-  name: String!
-  annotations: JSONObject!
-  annotation(name: String!): JSON
-  labels: JSONObject!
-  label(name: String!): JSON
-  uid: String!
-  etag: String!
-  generation: Int!
-}
-
-type ComponentMetadata implements EntityMetadata {
-  name: String!
-  annotations: JSONObject!
-  annotation(name: String!): JSON
-  labels: JSONObject!
-  label(name: String!): JSON
-  uid: String!
-  etag: String!
-  generation: Int!
-  relationships: String!
-}
-
-type TemplateMetadata implements EntityMetadata {
-  name: String!
-  annotations: JSONObject!
-  annotation(name: String!): JSON
-  labels: JSONObject!
-  label(name: String!): JSON
-  uid: String!
-  etag: String!
-  generation: Int!
-  updatedBy: String!
-}
-
-type DefaultEntityMetadata implements EntityMetadata {
-  name: String!
-  annotations: JSONObject!
-  annotation(name: String!): JSON
-  labels: JSONObject!
-  label(name: String!): JSON
-  uid: String!
-  etag: String!
-  generation: Int!
-}
-
-type CatalogEntity {
-  apiVersion: String!
-  kind: String!
-  metadata: EntityMetadata!
-}
-
-type CatalogQuery {
-  list: [CatalogEntity!]!
-}
-
-type Query {
-  catalog: CatalogQuery!
-}
@@ -15,47 +15,23 @@
 */

 import { Logger } from 'winston';
-import fs from 'fs';
-import path from 'path';
 import { makeExecutableSchema } from 'apollo-server';
 import { GraphQLModule } from '@graphql-modules/core';
-import {
-  Resolvers,
-  CatalogQuery,
-  CatalogEntityTypes,
-  EntityMetadataResolvers,
-} from './types';
+import { Resolvers, CatalogQuery } from './types';
 import { Config } from '@backstage/config';
 import { CatalogClient } from '../service/client';
 import GraphQLJSON, { GraphQLJSONObject } from 'graphql-type-json';
+import { Entity } from '@backstage/catalog-model';

 export interface ModuleOptions {
  logger: Logger;
  config: Config;
 }

-const schemaPath = path.resolve(
-  require.resolve('@backstage/plugin-catalog-graphql/package.json'),
-  '../schema.gql',
-);
-
-const getSpecTypenameForEntity = (e: { kind?: string }) => {
-  switch (e.kind) {
-    case 'Component':
-      return 'ComponentEntity';
-    case 'Location':
-      return 'LocationEntity';
-    case 'Template':
-      return 'TemplateEntity';
-    default:
-      return null;
-  }
-};
-
 export async function createModule(
  options: ModuleOptions,
 ): Promise<GraphQLModule> {
-  const typeDefs = await fs.promises.readFile(schemaPath, 'utf-8');
+  const typeDefs = require('../schema');

  const catalogClient = new CatalogClient(
    options.config.getString('backend.baseUrl'),
@@ -64,6 +40,12 @@ export async function createModule(
  const resolvers: Resolvers = {
    JSON: GraphQLJSON,
    JSONObject: GraphQLJSONObject,
+    DefaultEntitySpec: {
+      raw: rootValue => {
+        const { entity } = rootValue as { entity: Entity };
+        return entity.spec ?? null;
+      },
+    },
    Query: {
      catalog: () => ({} as CatalogQuery),
    },
@@ -72,18 +54,15 @@ export async function createModule(
        return await catalogClient.list();
      },
    },
-    ComponentMetadata: {
-      relationships: () => 'boop',
-    },
-    TemplateMetadata: {
-      updatedBy: () => 'blam',
-    },
    CatalogEntity: {
-      metadata: e => ({ ...e.metadata!, catalogEntity: e }),
+      metadata: entity => ({ ...entity.metadata!, entity }),
+      spec: entity => ({ ...entity.spec!, entity }),
    },
    EntityMetadata: {
-      __resolveType: (obj: any) => {
-        const kind = obj.catalogEntity!.kind;
+      __resolveType: rootValue => {
+        const {
+          entity: { kind },
+        } = rootValue as { entity: Entity };
        switch (kind) {
          case 'Component':
            return 'ComponentMetadata';
@@ -94,23 +73,35 @@ export async function createModule(
        }
      },
      annotation: (e, { name }) => e.annotations?.[name] ?? null,
-      labels: e => e ?? {},
-      annotations: e => e ?? {},
+      labels: e => e.labels ?? {},
+      annotations: e => e.annotations ?? {},
      label: (e, { name }) => e.labels?.[name] ?? null,
    },
+    EntitySpec: {
+      __resolveType: rootValue => {
+        const {
+          entity: { kind },
+        } = rootValue as { entity: Entity };
+
+        switch (kind) {
+          case 'Component':
+            return 'ComponentEntitySpec';
+          case 'Template':
+            return 'TemplateEntitySpec';
+          default:
+            return 'DefaultEntitySpec';
+        }
+      },
+    },
  };

  const schema = makeExecutableSchema({
    typeDefs,
    resolvers,
    inheritResolversFromInterfaces: true,
-    resolverValidationOptions: {
-      allowResolversNotInSchema: true,
-    },
  });

  const module = new GraphQLModule({
-    resolverValidationOptions: {},
    extraSchemas: [schema],
    logger: options.logger as any,
  });
@@ -13,12 +13,22 @@
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
-import { GraphQLResolveInfo, GraphQLScalarType, GraphQLScalarTypeConfig } from 'graphql';
+import {
+  GraphQLResolveInfo,
+  GraphQLScalarType,
+  GraphQLScalarTypeConfig,
+} from 'graphql';
 import { ModuleContext } from '@graphql-modules/core';

 export type Maybe<T> = T | null;
-export type Exact<T extends { [key: string]: unknown }> = { [K in keyof T]: T[K] };
-export type RequireFields<T, K extends keyof T> = { [X in Exclude<keyof T, K>]?: T[X] } & { [P in K]-?: NonNullable<T[P]> };
+export type Exact<T extends { [key: string]: unknown }> = {
+  [K in keyof T]: T[K];
+};
+export type Omit<T, K extends keyof T> = Pick<T, Exclude<keyof T, K>>;
+export type RequireFields<T, K extends keyof T> = {
+  [X in Exclude<keyof T, K>]?: T[X];
+} &
+  { [P in K]-?: NonNullable<T[P]> };
 /** All built-in and custom scalars, mapped to their actual values */
 export type Scalars = {
  ID: string;
@@ -30,8 +40,6 @@ export type Scalars = {
  JSONObject: any;
 };

-
-
 export type EntityMetadata = {
  name: Scalars['String'];
  annotations: Scalars['JSONObject'];
@@ -43,26 +51,14 @@ export type EntityMetadata = {
  generation: Scalars['Int'];
 };

-
 export type EntityMetadataAnnotationArgs = {
  name: Scalars['String'];
 };

-
 export type EntityMetadataLabelArgs = {
  name: Scalars['String'];
 };

-export type ComponentMetadata = EntityMetadata & {
-  __typename?: 'ComponentMetadata';
-  relationships: Scalars['String'];
-};
-
-export type TemplateMetadata = EntityMetadata & {
-  __typename?: 'TemplateMetadata';
-  updatedBy: Scalars['String'];
-};
-
 export type DefaultEntityMetadata = EntityMetadata & {
  __typename?: 'DefaultEntityMetadata';
  name: Scalars['String'];
@@ -73,24 +69,97 @@ export type DefaultEntityMetadata = EntityMetadata & {
  uid: Scalars['String'];
  etag: Scalars['String'];
  generation: Scalars['Int'];
-  updatedBy: Scalars['String'];
 };

-
 export type DefaultEntityMetadataAnnotationArgs = {
  name: Scalars['String'];
 };

-
 export type DefaultEntityMetadataLabelArgs = {
  name: Scalars['String'];
 };

+export type ComponentMetadata = EntityMetadata & {
+  __typename?: 'ComponentMetadata';
+  name: Scalars['String'];
+  annotations: Scalars['JSONObject'];
+  annotation?: Maybe<Scalars['JSON']>;
+  labels: Scalars['JSONObject'];
+  label?: Maybe<Scalars['JSON']>;
+  uid: Scalars['String'];
+  etag: Scalars['String'];
+  generation: Scalars['Int'];
+  relationships?: Maybe<Scalars['String']>;
+};
+
+export type ComponentMetadataAnnotationArgs = {
+  name: Scalars['String'];
+};
+
+export type ComponentMetadataLabelArgs = {
+  name: Scalars['String'];
+};
+
+export type TemplateMetadata = EntityMetadata & {
+  __typename?: 'TemplateMetadata';
+  name: Scalars['String'];
+  annotations: Scalars['JSONObject'];
+  annotation?: Maybe<Scalars['JSON']>;
+  labels: Scalars['JSONObject'];
+  label?: Maybe<Scalars['JSON']>;
+  uid: Scalars['String'];
+  etag: Scalars['String'];
+  generation: Scalars['Int'];
+  updatedBy?: Maybe<Scalars['String']>;
+};
+
+export type TemplateMetadataAnnotationArgs = {
+  name: Scalars['String'];
+};
+
+export type TemplateMetadataLabelArgs = {
+  name: Scalars['String'];
+};
+
+export type TemplateEntitySpec = {
+  __typename?: 'TemplateEntitySpec';
+  type: Scalars['String'];
+  path?: Maybe<Scalars['String']>;
+  schema: Scalars['JSONObject'];
+  templater: Scalars['String'];
+};
+
+export type ComponentEntitySpec = {
+  __typename?: 'ComponentEntitySpec';
+  title: Scalars['String'];
+  lifecycle: Scalars['String'];
+  owner: Scalars['String'];
+};
+
+export type LocationEntitySpec = {
+  __typename?: 'LocationEntitySpec';
+  type: Scalars['String'];
+  target?: Maybe<Scalars['String']>;
+  targets: Array<Scalars['String']>;
+};
+
+export type DefaultEntitySpec = {
+  __typename?: 'DefaultEntitySpec';
+  raw?: Maybe<Scalars['JSONObject']>;
+};
+
+export type EntitySpec =
+  | DefaultEntitySpec
+  | TemplateEntitySpec
+  | LocationEntitySpec
+  | ComponentEntitySpec;
+
 export type CatalogEntity = {
  __typename?: 'CatalogEntity';
  apiVersion: Scalars['String'];
  kind: Scalars['String'];
-  metadata: EntityMetadata;
+  metadata?: Maybe<EntityMetadata>;
+  spec: EntitySpec;
 };

 export type CatalogQuery = {
@@ -108,7 +177,6 @@ export type ResolversObject<TObject> = WithIndex<TObject>;

 export type ResolverTypeWrapper<T> = Promise<T> | T;

-
 export type LegacyStitchingResolver<TResult, TParent, TContext, TArgs> = {
  fragment: string;
  resolve: ResolverFn<TResult, TParent, TContext, TArgs>;
@@ -118,7 +186,9 @@ export type NewStitchingResolver<TResult, TParent, TContext, TArgs> = {
  selectionSet: string;
  resolve: ResolverFn<TResult, TParent, TContext, TArgs>;
 };
-export type StitchingResolver<TResult, TParent, TContext, TArgs> = LegacyStitchingResolver<TResult, TParent, TContext, TArgs> | NewStitchingResolver<TResult, TParent, TContext, TArgs>;
+export type StitchingResolver<TResult, TParent, TContext, TArgs> =
+  | LegacyStitchingResolver<TResult, TParent, TContext, TArgs>
+  | NewStitchingResolver<TResult, TParent, TContext, TArgs>;
 export type Resolver<TResult, TParent = {}, TContext = {}, TArgs = {}> =
  | ResolverFn<TResult, TParent, TContext, TArgs>
  | StitchingResolver<TResult, TParent, TContext, TArgs>;
@@ -127,26 +197,42 @@ export type ResolverFn<TResult, TParent, TContext, TArgs> = (
  parent: TParent,
  args: TArgs,
  context: TContext,
-  info: GraphQLResolveInfo
+  info: GraphQLResolveInfo,
 ) => Promise<TResult> | TResult;

 export type SubscriptionSubscribeFn<TResult, TParent, TContext, TArgs> = (
  parent: TParent,
  args: TArgs,
  context: TContext,
-  info: GraphQLResolveInfo
+  info: GraphQLResolveInfo,
 ) => AsyncIterator<TResult> | Promise<AsyncIterator<TResult>>;

 export type SubscriptionResolveFn<TResult, TParent, TContext, TArgs> = (
  parent: TParent,
  args: TArgs,
  context: TContext,
-  info: GraphQLResolveInfo
+  info: GraphQLResolveInfo,
 ) => TResult | Promise<TResult>;

-export interface SubscriptionSubscriberObject<TResult, TKey extends string, TParent, TContext, TArgs> {
-  subscribe: SubscriptionSubscribeFn<{ [key in TKey]: TResult }, TParent, TContext, TArgs>;
-  resolve?: SubscriptionResolveFn<TResult, { [key in TKey]: TResult }, TContext, TArgs>;
+export interface SubscriptionSubscriberObject<
+  TResult,
+  TKey extends string,
+  TParent,
+  TContext,
+  TArgs
+> {
+  subscribe: SubscriptionSubscribeFn<
+    { [key in TKey]: TResult },
+    TParent,
+    TContext,
+    TArgs
+  >;
+  resolve?: SubscriptionResolveFn<
+    TResult,
+    { [key in TKey]: TResult },
+    TContext,
+    TArgs
+  >;
 }

 export interface SubscriptionResolverObject<TResult, TParent, TContext, TArgs> {
@@ -154,43 +240,82 @@ export interface SubscriptionResolverObject<TResult, TParent, TContext, TArgs> {
  resolve: SubscriptionResolveFn<TResult, any, TContext, TArgs>;
 }

-export type SubscriptionObject<TResult, TKey extends string, TParent, TContext, TArgs> =
+export type SubscriptionObject<
+  TResult,
+  TKey extends string,
+  TParent,
+  TContext,
+  TArgs
+> =
  | SubscriptionSubscriberObject<TResult, TKey, TParent, TContext, TArgs>
  | SubscriptionResolverObject<TResult, TParent, TContext, TArgs>;

-export type SubscriptionResolver<TResult, TKey extends string, TParent = {}, TContext = {}, TArgs = {}> =
-  | ((...args: any[]) => SubscriptionObject<TResult, TKey, TParent, TContext, TArgs>)
+export type SubscriptionResolver<
+  TResult,
+  TKey extends string,
+  TParent = {},
+  TContext = {},
+  TArgs = {}
+> =
+  | ((
+      ...args: any[]
+    ) => SubscriptionObject<TResult, TKey, TParent, TContext, TArgs>)
  | SubscriptionObject<TResult, TKey, TParent, TContext, TArgs>;

 export type TypeResolveFn<TTypes, TParent = {}, TContext = {}> = (
  parent: TParent,
  context: TContext,
-  info: GraphQLResolveInfo
+  info: GraphQLResolveInfo,
 ) => Maybe<TTypes> | Promise<Maybe<TTypes>>;

-export type IsTypeOfResolverFn<T = {}> = (obj: T, info: GraphQLResolveInfo) => boolean | Promise<boolean>;
+export type IsTypeOfResolverFn<T = {}> = (
+  obj: T,
+  info: GraphQLResolveInfo,
+) => boolean | Promise<boolean>;

 export type NextResolverFn<T> = () => Promise<T>;

-export type DirectiveResolverFn<TResult = {}, TParent = {}, TContext = {}, TArgs = {}> = (
+export type DirectiveResolverFn<
+  TResult = {},
+  TParent = {},
+  TContext = {},
+  TArgs = {}
+> = (
  next: NextResolverFn<TResult>,
  parent: TParent,
  args: TArgs,
  context: TContext,
-  info: GraphQLResolveInfo
+  info: GraphQLResolveInfo,
 ) => TResult | Promise<TResult>;

 /** Mapping between all available schema types and the resolvers types */
 export type ResolversTypes = ResolversObject<{
  JSON: ResolverTypeWrapper<Partial<Scalars['JSON']>>;
  JSONObject: ResolverTypeWrapper<Partial<Scalars['JSONObject']>>;
-  EntityMetadata: ResolversTypes['ComponentMetadata'] | ResolversTypes['TemplateMetadata'] | ResolversTypes['DefaultEntityMetadata'];
+  EntityMetadata:
+    | ResolversTypes['DefaultEntityMetadata']
+    | ResolversTypes['ComponentMetadata']
+    | ResolversTypes['TemplateMetadata'];
  String: ResolverTypeWrapper<Partial<Scalars['String']>>;
  Int: ResolverTypeWrapper<Partial<Scalars['Int']>>;
+  DefaultEntityMetadata: ResolverTypeWrapper<Partial<DefaultEntityMetadata>>;
  ComponentMetadata: ResolverTypeWrapper<Partial<ComponentMetadata>>;
  TemplateMetadata: ResolverTypeWrapper<Partial<TemplateMetadata>>;
-  DefaultEntityMetadata: ResolverTypeWrapper<Partial<DefaultEntityMetadata>>;
-  CatalogEntity: ResolverTypeWrapper<Partial<CatalogEntity>>;
+  TemplateEntitySpec: ResolverTypeWrapper<Partial<TemplateEntitySpec>>;
+  ComponentEntitySpec: ResolverTypeWrapper<Partial<ComponentEntitySpec>>;
+  LocationEntitySpec: ResolverTypeWrapper<Partial<LocationEntitySpec>>;
+  DefaultEntitySpec: ResolverTypeWrapper<Partial<DefaultEntitySpec>>;
+  EntitySpec: Partial<
+    | ResolversTypes['DefaultEntitySpec']
+    | ResolversTypes['TemplateEntitySpec']
+    | ResolversTypes['LocationEntitySpec']
+    | ResolversTypes['ComponentEntitySpec']
+  >;
+  CatalogEntity: ResolverTypeWrapper<
+    Partial<
+      Omit<CatalogEntity, 'spec'> & { spec: ResolversTypes['EntitySpec'] }
+    >
+  >;
  CatalogQuery: ResolverTypeWrapper<Partial<CatalogQuery>>;
  Query: ResolverTypeWrapper<{}>;
  Boolean: ResolverTypeWrapper<Partial<Scalars['Boolean']>>;
@@ -200,74 +325,241 @@ export type ResolversTypes = ResolversObject<{
 export type ResolversParentTypes = ResolversObject<{
  JSON: Partial<Scalars['JSON']>;
  JSONObject: Partial<Scalars['JSONObject']>;
-  EntityMetadata: ResolversParentTypes['ComponentMetadata'] | ResolversParentTypes['TemplateMetadata'] | ResolversParentTypes['DefaultEntityMetadata'];
+  EntityMetadata:
+    | ResolversParentTypes['DefaultEntityMetadata']
+    | ResolversParentTypes['ComponentMetadata']
+    | ResolversParentTypes['TemplateMetadata'];
  String: Partial<Scalars['String']>;
  Int: Partial<Scalars['Int']>;
+  DefaultEntityMetadata: Partial<DefaultEntityMetadata>;
  ComponentMetadata: Partial<ComponentMetadata>;
  TemplateMetadata: Partial<TemplateMetadata>;
-  DefaultEntityMetadata: Partial<DefaultEntityMetadata>;
-  CatalogEntity: Partial<CatalogEntity>;
+  TemplateEntitySpec: Partial<TemplateEntitySpec>;
+  ComponentEntitySpec: Partial<ComponentEntitySpec>;
+  LocationEntitySpec: Partial<LocationEntitySpec>;
+  DefaultEntitySpec: Partial<DefaultEntitySpec>;
+  EntitySpec: Partial<
+    | ResolversParentTypes['DefaultEntitySpec']
+    | ResolversParentTypes['TemplateEntitySpec']
+    | ResolversParentTypes['LocationEntitySpec']
+    | ResolversParentTypes['ComponentEntitySpec']
+  >;
+  CatalogEntity: Partial<
+    Omit<CatalogEntity, 'spec'> & { spec: ResolversParentTypes['EntitySpec'] }
+  >;
  CatalogQuery: Partial<CatalogQuery>;
  Query: {};
  Boolean: Partial<Scalars['Boolean']>;
 }>;

-export interface JsonScalarConfig extends GraphQLScalarTypeConfig<ResolversTypes['JSON'], any> {
+export interface JsonScalarConfig
+  extends GraphQLScalarTypeConfig<ResolversTypes['JSON'], any> {
  name: 'JSON';
 }

-export interface JsonObjectScalarConfig extends GraphQLScalarTypeConfig<ResolversTypes['JSONObject'], any> {
+export interface JsonObjectScalarConfig
+  extends GraphQLScalarTypeConfig<ResolversTypes['JSONObject'], any> {
  name: 'JSONObject';
 }

-export type EntityMetadataResolvers<ContextType = ModuleContext, ParentType extends ResolversParentTypes['EntityMetadata'] = ResolversParentTypes['EntityMetadata']> = ResolversObject<{
-  __resolveType: TypeResolveFn<'ComponentMetadata' | 'TemplateMetadata' | 'DefaultEntityMetadata', ParentType, ContextType>;
+export type EntityMetadataResolvers<
+  ContextType = ModuleContext,
+  ParentType = ResolversParentTypes['EntityMetadata']
+> = ResolversObject<{
+  __resolveType: TypeResolveFn<
+    'DefaultEntityMetadata' | 'ComponentMetadata' | 'TemplateMetadata',
+    ParentType,
+    ContextType
+  >;
  name?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
  annotations?: Resolver<ResolversTypes['JSONObject'], ParentType, ContextType>;
-  annotation?: Resolver<Maybe<ResolversTypes['JSON']>, ParentType, ContextType, RequireFields<EntityMetadataAnnotationArgs, 'name'>>;
+  annotation?: Resolver<
+    Maybe<ResolversTypes['JSON']>,
+    ParentType,
+    ContextType,
+    RequireFields<EntityMetadataAnnotationArgs, 'name'>
+  >;
  labels?: Resolver<ResolversTypes['JSONObject'], ParentType, ContextType>;
-  label?: Resolver<Maybe<ResolversTypes['JSON']>, ParentType, ContextType, RequireFields<EntityMetadataLabelArgs, 'name'>>;
+  label?: Resolver<
+    Maybe<ResolversTypes['JSON']>,
+    ParentType,
+    ContextType,
+    RequireFields<EntityMetadataLabelArgs, 'name'>
+  >;
  uid?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
  etag?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
  generation?: Resolver<ResolversTypes['Int'], ParentType, ContextType>;
 }>;

-export type ComponentMetadataResolvers<ContextType = ModuleContext, ParentType extends ResolversParentTypes['ComponentMetadata'] = ResolversParentTypes['ComponentMetadata']> = ResolversObject<{
-  relationships?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
-  __isTypeOf?: IsTypeOfResolverFn<ParentType>;
-}>;
-
-export type TemplateMetadataResolvers<ContextType = ModuleContext, ParentType extends ResolversParentTypes['TemplateMetadata'] = ResolversParentTypes['TemplateMetadata']> = ResolversObject<{
-  updatedBy?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
-  __isTypeOf?: IsTypeOfResolverFn<ParentType>;
-}>;
-
-export type DefaultEntityMetadataResolvers<ContextType = ModuleContext, ParentType extends ResolversParentTypes['DefaultEntityMetadata'] = ResolversParentTypes['DefaultEntityMetadata']> = ResolversObject<{
+export type DefaultEntityMetadataResolvers<
+  ContextType = ModuleContext,
+  ParentType = ResolversParentTypes['DefaultEntityMetadata']
+> = ResolversObject<{
  name?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
  annotations?: Resolver<ResolversTypes['JSONObject'], ParentType, ContextType>;
-  annotation?: Resolver<Maybe<ResolversTypes['JSON']>, ParentType, ContextType, RequireFields<DefaultEntityMetadataAnnotationArgs, 'name'>>;
+  annotation?: Resolver<
+    Maybe<ResolversTypes['JSON']>,
+    ParentType,
+    ContextType,
+    RequireFields<DefaultEntityMetadataAnnotationArgs, 'name'>
+  >;
  labels?: Resolver<ResolversTypes['JSONObject'], ParentType, ContextType>;
-  label?: Resolver<Maybe<ResolversTypes['JSON']>, ParentType, ContextType, RequireFields<DefaultEntityMetadataLabelArgs, 'name'>>;
+  label?: Resolver<
+    Maybe<ResolversTypes['JSON']>,
+    ParentType,
+    ContextType,
+    RequireFields<DefaultEntityMetadataLabelArgs, 'name'>
+  >;
  uid?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
  etag?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
  generation?: Resolver<ResolversTypes['Int'], ParentType, ContextType>;
-  updatedBy?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType>;
 }>;

-export type CatalogEntityResolvers<ContextType = ModuleContext, ParentType extends ResolversParentTypes['CatalogEntity'] = ResolversParentTypes['CatalogEntity']> = ResolversObject<{
+export type ComponentMetadataResolvers<
+  ContextType = ModuleContext,
+  ParentType = ResolversParentTypes['ComponentMetadata']
+> = ResolversObject<{
+  name?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
+  annotations?: Resolver<ResolversTypes['JSONObject'], ParentType, ContextType>;
+  annotation?: Resolver<
+    Maybe<ResolversTypes['JSON']>,
+    ParentType,
+    ContextType,
+    RequireFields<ComponentMetadataAnnotationArgs, 'name'>
+  >;
+  labels?: Resolver<ResolversTypes['JSONObject'], ParentType, ContextType>;
+  label?: Resolver<
+    Maybe<ResolversTypes['JSON']>,
+    ParentType,
+    ContextType,
+    RequireFields<ComponentMetadataLabelArgs, 'name'>
+  >;
+  uid?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
+  etag?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
+  generation?: Resolver<ResolversTypes['Int'], ParentType, ContextType>;
+  relationships?: Resolver<
+    Maybe<ResolversTypes['String']>,
+    ParentType,
+    ContextType
+  >;
+  __isTypeOf?: IsTypeOfResolverFn<ParentType>;
+}>;
+
+export type TemplateMetadataResolvers<
+  ContextType = ModuleContext,
+  ParentType = ResolversParentTypes['TemplateMetadata']
+> = ResolversObject<{
+  name?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
+  annotations?: Resolver<ResolversTypes['JSONObject'], ParentType, ContextType>;
+  annotation?: Resolver<
+    Maybe<ResolversTypes['JSON']>,
+    ParentType,
+    ContextType,
+    RequireFields<TemplateMetadataAnnotationArgs, 'name'>
+  >;
+  labels?: Resolver<ResolversTypes['JSONObject'], ParentType, ContextType>;
+  label?: Resolver<
+    Maybe<ResolversTypes['JSON']>,
+    ParentType,
+    ContextType,
+    RequireFields<TemplateMetadataLabelArgs, 'name'>
+  >;
+  uid?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
+  etag?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
+  generation?: Resolver<ResolversTypes['Int'], ParentType, ContextType>;
+  updatedBy?: Resolver<
+    Maybe<ResolversTypes['String']>,
+    ParentType,
+    ContextType
+  >;
+  __isTypeOf?: IsTypeOfResolverFn<ParentType>;
+}>;
+
+export type TemplateEntitySpecResolvers<
+  ContextType = ModuleContext,
+  ParentType = ResolversParentTypes['TemplateEntitySpec']
+> = ResolversObject<{
+  type?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
+  path?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
+  schema?: Resolver<ResolversTypes['JSONObject'], ParentType, ContextType>;
+  templater?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
+  __isTypeOf?: IsTypeOfResolverFn<ParentType>;
+}>;
+
+export type ComponentEntitySpecResolvers<
+  ContextType = ModuleContext,
+  ParentType = ResolversParentTypes['ComponentEntitySpec']
+> = ResolversObject<{
+  title?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
+  lifecycle?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
+  owner?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
+  __isTypeOf?: IsTypeOfResolverFn<ParentType>;
+}>;
+
+export type LocationEntitySpecResolvers<
+  ContextType = ModuleContext,
+  ParentType = ResolversParentTypes['LocationEntitySpec']
+> = ResolversObject<{
+  type?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
+  target?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
+  targets?: Resolver<Array<ResolversTypes['String']>, ParentType, ContextType>;
+  __isTypeOf?: IsTypeOfResolverFn<ParentType>;
+}>;
+
+export type DefaultEntitySpecResolvers<
+  ContextType = ModuleContext,
+  ParentType = ResolversParentTypes['DefaultEntitySpec']
+> = ResolversObject<{
+  raw?: Resolver<Maybe<ResolversTypes['JSONObject']>, ParentType, ContextType>;
+  __isTypeOf?: IsTypeOfResolverFn<ParentType>;
+}>;
+
+export type EntitySpecResolvers<
+  ContextType = ModuleContext,
+  ParentType = ResolversParentTypes['EntitySpec']
+> = ResolversObject<{
+  __resolveType: TypeResolveFn<
+    | 'DefaultEntitySpec'
+    | 'TemplateEntitySpec'
+    | 'LocationEntitySpec'
+    | 'ComponentEntitySpec',
+    ParentType,
+    ContextType
+  >;
+}>;
+
+export type CatalogEntityResolvers<
+  ContextType = ModuleContext,
+  ParentType = ResolversParentTypes['CatalogEntity']
+> = ResolversObject<{
  apiVersion?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
  kind?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
-  metadata?: Resolver<ResolversTypes['EntityMetadata'], ParentType, ContextType>;
+  metadata?: Resolver<
+    Maybe<ResolversTypes['EntityMetadata']>,
+    ParentType,
+    ContextType
+  >;
+  spec?: Resolver<ResolversTypes['EntitySpec'], ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType>;
 }>;

-export type CatalogQueryResolvers<ContextType = ModuleContext, ParentType extends ResolversParentTypes['CatalogQuery'] = ResolversParentTypes['CatalogQuery']> = ResolversObject<{
-  list?: Resolver<Array<ResolversTypes['CatalogEntity']>, ParentType, ContextType>;
+export type CatalogQueryResolvers<
+  ContextType = ModuleContext,
+  ParentType = ResolversParentTypes['CatalogQuery']
+> = ResolversObject<{
+  list?: Resolver<
+    Array<ResolversTypes['CatalogEntity']>,
+    ParentType,
+    ContextType
+  >;
  __isTypeOf?: IsTypeOfResolverFn<ParentType>;
 }>;

-export type QueryResolvers<ContextType = ModuleContext, ParentType extends ResolversParentTypes['Query'] = ResolversParentTypes['Query']> = ResolversObject<{
+export type QueryResolvers<
+  ContextType = ModuleContext,
+  ParentType = ResolversParentTypes['Query']
+> = ResolversObject<{
  catalog?: Resolver<ResolversTypes['CatalogQuery'], ParentType, ContextType>;
 }>;

@@ -275,15 +567,19 @@ export type Resolvers<ContextType = ModuleContext> = ResolversObject<{
  JSON?: GraphQLScalarType;
  JSONObject?: GraphQLScalarType;
  EntityMetadata?: EntityMetadataResolvers<ContextType>;
+  DefaultEntityMetadata?: DefaultEntityMetadataResolvers<ContextType>;
  ComponentMetadata?: ComponentMetadataResolvers<ContextType>;
  TemplateMetadata?: TemplateMetadataResolvers<ContextType>;
-  DefaultEntityMetadata?: DefaultEntityMetadataResolvers<ContextType>;
+  TemplateEntitySpec?: TemplateEntitySpecResolvers<ContextType>;
+  ComponentEntitySpec?: ComponentEntitySpecResolvers<ContextType>;
+  LocationEntitySpec?: LocationEntitySpecResolvers<ContextType>;
+  DefaultEntitySpec?: DefaultEntitySpecResolvers<ContextType>;
+  EntitySpec?: EntitySpecResolvers<ContextType>;
  CatalogEntity?: CatalogEntityResolvers<ContextType>;
  CatalogQuery?: CatalogQueryResolvers<ContextType>;
  Query?: QueryResolvers<ContextType>;
 }>;

-
 /**
 * @deprecated
 * Use "Resolvers" root object instead. If you wish to get "IResolvers", add "typesPrefix: I" to your config.