@commitspark/graphql-api 0.7.0

package/src/graphql/schema-generator.service.ts

@@ -0,0 +1,190 @@
+import {
+  IGeneratedSchema,
+  QueriesMutationsGeneratorService,
+} from './queries-mutations-generator.service'
+import {
+  IExecutableSchemaDefinition,
+  makeExecutableSchema,
+} from '@graphql-tools/schema'
+import { SchemaAnalyzerService } from './schema-analyzer.service'
+import { InputTypeGeneratorService } from './input-type-generator.service'
+import { SchemaRootTypeGeneratorService } from './schema-root-type-generator.service'
+import { printSchemaWithDirectives } from '@graphql-tools/utils'
+import { EntryReferenceResolverGenerator } from './resolver-generators/entry-reference-resolver.generator'
+import { UnionTypeResolverGenerator } from './resolver-generators/union-type-resolver-generator'
+import { ApolloContext } from '../app/api.service'
+import {
+  GraphQLFieldResolver,
+  GraphQLTypeResolver,
+} from 'graphql/type/definition'
+import { SchemaValidator } from './schema-validator'
+import { Entry } from '../persistence/persistence.service'
+import { UnionValueResolverGenerator } from './resolver-generators/union-value-resolver-generator'
+
+export class SchemaGeneratorService {
+  constructor(
+    private readonly queriesMutationsGenerator: QueriesMutationsGeneratorService,
+    private readonly schemaAnalyzer: SchemaAnalyzerService,
+    private readonly inputTypeGenerator: InputTypeGeneratorService,
+    private readonly schemaRootTypeGenerator: SchemaRootTypeGeneratorService,
+    private readonly entryReferenceResolverGenerator: EntryReferenceResolverGenerator,
+    private readonly unionTypeResolverGenerator: UnionTypeResolverGenerator,
+    private readonly unionValueResolverGenerator: UnionValueResolverGenerator,
+    private readonly schemaValidator: SchemaValidator,
+  ) {}
+
+  public async generateSchema(
+    context: ApolloContext,
+  ): Promise<IExecutableSchemaDefinition> {
+    const originalSchemaString = await context.gitAdapter.getSchema(
+      context.getCurrentRef(),
+    )
+    const schema = makeExecutableSchema({
+      typeDefs: originalSchemaString,
+    })
+
+    const validationResult = this.schemaValidator.getValidationResult(schema)
+    if (validationResult.length > 0) {
+      throw new Error(validationResult.join('\n'))
+    }
+    const schemaAnalyzerResult = this.schemaAnalyzer.analyzeSchema(schema)
+
+    const filteredOriginalSchemaString = printSchemaWithDirectives(schema)
+
+    const generatedIdInputTypeStrings =
+      this.inputTypeGenerator.generateIdInputTypeStrings(schemaAnalyzerResult)
+
+    const generatedQueriesMutations =
+      this.queriesMutationsGenerator.generateFromAnalyzedSchema(
+        schemaAnalyzerResult.entryDirectiveTypes,
+      )
+    const generatedTypeNameQuery =
+      this.queriesMutationsGenerator.generateTypeNameQuery()
+
+    let generatedEntryReferenceResolvers: Record<
+      string,
+      Record<
+        string,
+        GraphQLFieldResolver<
+          Record<string, any>,
+          ApolloContext,
+          any,
+          Promise<Entry | Entry[] | undefined>
+        >
+      >
+    > = {}
+    for (const type of schemaAnalyzerResult.typesWithEntryReferences) {
+      generatedEntryReferenceResolvers[type.type.name] =
+        this.entryReferenceResolverGenerator.createResolver(context, type)
+    }
+
+    const generatedObjectInputTypeStrings =
+      this.inputTypeGenerator.generateObjectInputTypeStrings(
+        schemaAnalyzerResult.objectTypes,
+      )
+
+    const generatedUnionInputTypeStrings =
+      this.inputTypeGenerator.generateUnionInputTypeStrings(
+        schemaAnalyzerResult.unionTypes,
+      )
+
+    const generatedSchemaRootTypeStrings =
+      this.schemaRootTypeGenerator.generateSchemaRootTypeStrings(
+        generatedQueriesMutations,
+        generatedTypeNameQuery,
+      )
+
+    const generatedSchemaString =
+      'schema {\n  query: Query\n  mutation: Mutation\n}\n\n' +
+      generatedSchemaRootTypeStrings +
+      '\n' +
+      'type ListMetadata {\n' +
+      '  count: Int!\n' +
+      '}\n\n' +
+      'type DeletionResult {\n' +
+      '  id: ID\n' +
+      '}\n'
+
+    const generatedUnionTypeResolvers: Record<string, UnionTypeResolver> = {}
+    for (const unionType of schemaAnalyzerResult.unionTypes) {
+      generatedUnionTypeResolvers[unionType.name] = {
+        __resolveType: this.unionTypeResolverGenerator.createResolver(),
+      }
+    }
+    const generatedUnionValueResolvers =
+      this.unionValueResolverGenerator.createResolver(schema)
+
+    const generatedQueryResolvers: Record<
+      string,
+      GraphQLFieldResolver<any, ApolloContext>
+    > = {}
+    const generatedMutationResolvers: Record<
+      string,
+      GraphQLFieldResolver<any, ApolloContext>
+    > = {}
+
+    generatedQueriesMutations.forEach(function (
+      element: IGeneratedSchema,
+    ): void {
+      generatedQueryResolvers[element.queryAll.name] = element.queryAll.resolver
+      generatedQueryResolvers[element.queryAllMeta.name] =
+        element.queryAllMeta.resolver
+      generatedQueryResolvers[element.queryById.name] =
+        element.queryById.resolver
+      generatedMutationResolvers[element.createMutation.name] =
+        element.createMutation.resolver
+      generatedMutationResolvers[element.updateMutation.name] =
+        element.updateMutation.resolver
+      generatedMutationResolvers[element.deleteMutation.name] =
+        element.deleteMutation.resolver
+    })
+    generatedQueryResolvers[generatedTypeNameQuery.name] =
+      generatedTypeNameQuery.resolver
+
+    const allGeneratedResolvers: Record<
+      string,
+      Record<
+        string,
+        | GraphQLFieldResolver<any, ApolloContext>
+        | GraphQLTypeResolver<any, ApolloContext>
+      >
+    > = {
+      Query: generatedQueryResolvers,
+      Mutation: generatedMutationResolvers,
+    }
+
+    for (const typeName of Object.keys(generatedUnionTypeResolvers)) {
+      allGeneratedResolvers[typeName] = {
+        ...(allGeneratedResolvers[typeName] ?? {}),
+        ...generatedUnionTypeResolvers[typeName],
+      }
+    }
+    for (const typeName of Object.keys(generatedUnionValueResolvers)) {
+      allGeneratedResolvers[typeName] = {
+        ...(allGeneratedResolvers[typeName] ?? {}),
+        ...generatedUnionValueResolvers[typeName],
+      }
+    }
+    for (const typeName of Object.keys(generatedEntryReferenceResolvers)) {
+      allGeneratedResolvers[typeName] = {
+        ...(allGeneratedResolvers[typeName] ?? {}),
+        ...generatedEntryReferenceResolvers[typeName],
+      }
+    }
+
+    return {
+      typeDefs: [
+        filteredOriginalSchemaString,
+        generatedSchemaString,
+        generatedIdInputTypeStrings.join('\n'),
+        generatedObjectInputTypeStrings.join('\n'),
+        generatedUnionInputTypeStrings.join('\n'),
+      ],
+      resolvers: allGeneratedResolvers,
+    }
+  }
+}
+
+interface UnionTypeResolver {
+  __resolveType: GraphQLTypeResolver<any, ApolloContext>
+}

package/src/graphql/schema-root-type-generator.service.ts

@@ -0,0 +1,42 @@
+import {
+  IGeneratedQuery,
+  IGeneratedSchema,
+} from './queries-mutations-generator.service'
+
+export class SchemaRootTypeGeneratorService {
+  public generateSchemaRootTypeStrings(
+    generatedSchemas: IGeneratedSchema[],
+    typeQuery: IGeneratedQuery<Promise<string>>,
+  ): string {
+    return (
+      `type Query {\n` +
+      generatedSchemas
+        .map((generated) => '  ' + generated.queryAll.schemaString)
+        .join('\n') +
+      generatedSchemas
+        .map((generated) => '  ' + generated.queryAllMeta.schemaString)
+        .join('\n') +
+      generatedSchemas
+        .map((generated) => '  ' + generated.queryById.schemaString)
+        .join('\n') +
+      '\n' +
+      `  ${typeQuery.schemaString}` +
+      '\n' +
+      '}\n' +
+      'type Mutation {\n' +
+      generatedSchemas
+        .map((generated) => '  ' + generated.createMutation.schemaString)
+        .join('\n') +
+      '\n' +
+      generatedSchemas
+        .map((generated) => '  ' + generated.updateMutation.schemaString)
+        .join('\n') +
+      '\n' +
+      generatedSchemas
+        .map((generated) => '  ' + generated.deleteMutation.schemaString)
+        .join('\n') +
+      '\n' +
+      '}\n'
+    )
+  }
+}

package/src/graphql/schema-utils/entry-reference-util.ts

@@ -0,0 +1,49 @@
+import {
+  GraphQLField,
+  GraphQLList,
+  GraphQLNonNull,
+  GraphQLObjectType,
+} from 'graphql/type'
+import { GraphQLNullableType, GraphQLUnionType } from 'graphql/type/definition'
+
+export class EntryReferenceUtil {
+  public getFieldsWithReferenceToTypeWithEntryDirective(
+    objectType: GraphQLObjectType,
+  ): GraphQLField<any, any>[] {
+    const fields = []
+    for (const fieldsKey in objectType.getFields()) {
+      const field: GraphQLField<any, any> = objectType.getFields()[fieldsKey]
+      if (this.buildsOnTypeWithEntryDirective(field.type)) {
+        fields.push(field)
+      }
+    }
+    return fields
+  }
+
+  public buildsOnTypeWithEntryDirective(type: GraphQLNullableType): boolean {
+    if (type instanceof GraphQLNonNull) {
+      return this.buildsOnTypeWithEntryDirective(type.ofType)
+    } else if (type instanceof GraphQLList) {
+      return this.buildsOnTypeWithEntryDirective(type.ofType)
+    } else if (type instanceof GraphQLUnionType) {
+      return (
+        type
+          .getTypes()
+          .filter((unionType) => this.buildsOnTypeWithEntryDirective(unionType))
+          .length > 0
+      )
+    } else if (type instanceof GraphQLObjectType) {
+      return this.hasEntryDirective(type)
+    }
+    return false
+  }
+
+  public hasEntryDirective(type: GraphQLObjectType): boolean {
+    return (
+      !!type.astNode &&
+      type.astNode.directives?.find(
+        (directive) => directive.name.value === 'Entry',
+      ) !== undefined
+    )
+  }
+}

package/src/graphql/schema-validator.ts

@@ -0,0 +1,41 @@
+import { GraphQLSchema } from 'graphql'
+import { Kind } from 'graphql/language/kinds'
+import { GraphQLUnionType } from 'graphql/type/definition'
+
+export class SchemaValidator {
+  public getValidationResult(schema: GraphQLSchema): string[] {
+    const results = []
+    results.push(this.checkUnionMembersConsistentUseOfEntryDirective(schema))
+    return results.filter((result) => result !== '')
+  }
+
+  private checkUnionMembersConsistentUseOfEntryDirective(
+    schema: GraphQLSchema,
+  ): string {
+    const typeMap = schema.getTypeMap()
+
+    for (const [key, type] of Object.entries(typeMap)) {
+      if (type.astNode?.kind !== Kind.UNION_TYPE_DEFINITION) {
+        continue
+      }
+      const innerTypes = (type as GraphQLUnionType).getTypes()
+
+      const numberUnionMembersWithEntryDirective = innerTypes.filter(
+        (innerType) =>
+          !!innerType.astNode &&
+          innerType.astNode.directives?.find(
+            (directive) => directive.name.value === 'Entry',
+          ) !== undefined,
+      ).length
+
+      if (
+        numberUnionMembersWithEntryDirective !== 0 &&
+        numberUnionMembersWithEntryDirective !== innerTypes.length
+      ) {
+        return `Either all union members of "${type.name}" must have "@Entry" directive or none.`
+      }
+    }
+
+    return ''
+  }
+}

package/src/index.ts

@@ -0,0 +1,8 @@
+import { ApiService } from './app/api.service'
+import { apiService } from './container'
+
+export { ApiService }
+
+export async function getApiService(): Promise<ApiService> {
+  return apiService
+}

package/src/persistence/persistence.service.ts

@@ -0,0 +1,183 @@
+import { v4 as uuidv4 } from 'uuid'
+import { ContentEntry, GitAdapter } from '@commitspark/git-adapter'
+
+export class PersistenceService {
+  constructor() {}
+
+  public async getTypeById(
+    gitAdapter: GitAdapter,
+    commitHash: string,
+    id: ID,
+  ): Promise<string> {
+    const allEntries = await gitAdapter.getContentEntries(commitHash)
+    const requestedEntry = allEntries.filter(
+      (contentEntry: ContentEntry) => contentEntry.id === (id as string),
+    )[0]
+    if (requestedEntry === undefined) {
+      throw new Error(`Not found: ${id}`)
+    }
+
+    return requestedEntry.metadata.type
+  }
+
+  public async findById(
+    gitAdapter: GitAdapter,
+    commitHash: string,
+    id: ID,
+  ): Promise<Entry> {
+    const allEntries = await gitAdapter.getContentEntries(commitHash)
+    const requestedEntry = allEntries.filter(
+      (contentEntry: ContentEntry) => contentEntry.id === (id as string),
+    )[0]
+    if (requestedEntry === undefined) {
+      throw new Error(`Not found: ${id}`)
+    }
+
+    return { ...requestedEntry.data, id: id }
+  }
+
+  public async findByType(
+    gitAdapter: GitAdapter,
+    commitHash: string,
+    type: string,
+  ): Promise<Entry[]> {
+    const allEntries = await gitAdapter.getContentEntries(commitHash)
+    return allEntries
+      .filter(
+        (contentEntry: ContentEntry) => contentEntry.metadata.type === type,
+      )
+      .map((value) => ({ ...value.data, id: value.id }))
+  }
+
+  public async findByTypeId(
+    gitAdapter: GitAdapter,
+    commitHash: string,
+    type: string,
+    id: ID,
+  ): Promise<Entry> {
+    const allEntries = await gitAdapter.getContentEntries(commitHash)
+    const requestedEntry = allEntries.filter(
+      (contentEntry: ContentEntry) => contentEntry.id === (id as string),
+    )[0]
+    if (requestedEntry === undefined || requestedEntry.metadata.type !== type) {
+      throw new Error(`Not found: ${type}, ${id}`)
+    }
+
+    return { ...requestedEntry.data, id: id }
+  }
+
+  public async createType(
+    gitAdapter: GitAdapter,
+    branch: string,
+    commitHash: string,
+    type: string,
+    data: Entry,
+    message: string,
+  ): Promise<CommitResult> {
+    const id = uuidv4()
+    const commit = await gitAdapter.createCommit({
+      ref: branch,
+      parentSha: commitHash,
+      contentEntries: [
+        {
+          id: id,
+          data: data,
+          metadata: {
+            type: type,
+          },
+          deletion: false,
+        },
+      ],
+      message: message,
+    })
+
+    return {
+      id,
+      ref: commit.ref,
+    }
+  }
+
+  public async updateByTypeId(
+    gitAdapter: GitAdapter,
+    branch: string,
+    commitHash: string,
+    type: string,
+    id: ID,
+    data: Entry,
+    message: string,
+  ): Promise<CommitResult> {
+    const allEntries = await gitAdapter.getContentEntries(commitHash)
+    const requestedEntry = allEntries.filter(
+      (contentEntry: ContentEntry) => contentEntry.id === (id as string),
+    )[0]
+    if (requestedEntry === undefined || requestedEntry.metadata.type !== type) {
+      throw new Error(`Not found: ${type}, ${id}`)
+    }
+
+    const newData: Entry = { ...requestedEntry.data, ...data }
+
+    const commit = await gitAdapter.createCommit({
+      ref: branch,
+      parentSha: commitHash,
+      contentEntries: [
+        {
+          id: id,
+          data: newData,
+          metadata: requestedEntry.metadata,
+          deletion: false,
+        },
+      ],
+      message: message,
+    })
+
+    return {
+      id,
+      ref: commit.ref,
+    }
+  }
+
+  public async deleteByTypeId(
+    gitAdapter: GitAdapter,
+    branch: string,
+    commitHash: string,
+    type: string,
+    id: ID,
+    message: string,
+  ): Promise<CommitResult> {
+    const allEntries = await gitAdapter.getContentEntries(commitHash)
+    const requestedEntry = allEntries.filter(
+      (contentEntry: ContentEntry) => contentEntry.id === (id as string),
+    )[0]
+    if (requestedEntry === undefined || requestedEntry.metadata.type !== type) {
+      throw new Error(`Not found: ${type}, ${id}`)
+    }
+
+    const commit = await gitAdapter.createCommit({
+      ref: branch,
+      parentSha: commitHash,
+      contentEntries: [
+        {
+          id: id,
+          data: {},
+          metadata: requestedEntry.metadata,
+          deletion: true,
+        },
+      ],
+      message: message,
+    })
+
+    return {
+      id,
+      ref: commit.ref,
+    }
+  }
+}
+
+export interface CommitResult {
+  id: ID
+  ref: string // commit sha
+}
+
+export type ID = string
+
+export type Entry = Record<string, unknown>

package/tsconfig.build.json

@@ -0,0 +1,10 @@
+{
+  "extends": "./tsconfig.json",
+  "exclude": [
+    "node_modules",
+    "dist",
+    "test",
+    "**/*spec.ts",
+    "doc/example"
+  ]
+}

package/tsconfig.json

@@ -0,0 +1,18 @@
+{
+  "compilerOptions": {
+    "module": "commonjs",
+    "declaration": true,
+    "removeComments": true,
+    "emitDecoratorMetadata": true,
+    "experimentalDecorators": true,
+    "allowSyntheticDefaultImports": true,
+    "target": "es2017",
+    "sourceMap": true,
+    "outDir": "./dist",
+    "baseUrl": "./",
+    "incremental": true,
+    "skipLibCheck": true,
+    "esModuleInterop": true,
+    "strict": true
+  }
+}

package/webpack.config.js

@@ -0,0 +1,25 @@
+const path = require('node:path')
+module.exports = (options, webpack) => {
+  return {
+    ...options,
+    devtool: 'source-map', // create source map for debugging
+    externals: [],
+    entry: {
+      main: './src/index.ts',
+    },
+    output: {
+      ...options.output,
+      libraryTarget: 'commonjs2',
+    },
+    plugins: [
+      ...options.plugins,
+    ],
+    resolve: {
+      // @see https://github.com/apollographql/apollo-server/issues/4983
+      extensions: ['.ts', '.js'],
+      alias: {
+        graphql$: path.resolve(__dirname, 'node_modules/graphql/index.js'),
+      },
+    },
+  }
+}