@commitspark/graphql-api 0.8.0 → 0.9.1

package/src/graphql/resolver-generators/mutation-create-resolver-generator.ts

@@ -4,6 +4,7 @@ import {
   Entry,
   PersistenceService,
 } from '../../persistence/persistence.service'
+import { GraphQLError } from 'graphql/error/GraphQLError'
 
 export class MutationCreateResolverGenerator {
   constructor(private readonly persistence: PersistenceService) {}
@@ -17,21 +18,39 @@ export class MutationCreateResolverGenerator {
       context: ApolloContext,
       info,
     ): Promise<Entry> => {
-      // TODO validate ID references in payload to assert referenced ID exists and points to correct entry type
-      const createResult = await this.persistence.createType(
+      let existingEntry
+      try {
+        existingEntry = await this.persistence.findById(
+          context.gitAdapter,
+          context.getCurrentRef(),
+          args.id,
+        )
+      } catch (_) {}
+      if (existingEntry) {
+        throw new GraphQLError(`An entry with id "${args.id}" already exists`, {
+          extensions: {
+            code: 'BAD_USER_INPUT',
+            argumentName: 'id',
+          },
+        })
+      }
+
+      // TODO validate ID references within args.data to assert referenced IDs exist and point to correct entry type
+      const commitResult = await this.persistence.createType(
         context.gitAdapter,
         context.branch,
         context.getCurrentRef(),
         typeName,
+        args.id,
         args.data,
         args.message,
       )
-      context.setCurrentRef(createResult.ref)
+      context.setCurrentRef(commitResult.ref)
       return this.persistence.findByTypeId(
         context.gitAdapter,
         context.getCurrentRef(),
         typeName,
-        createResult.id,
+        args.id,
       )
     }
   }

package/src/graphql/resolver-generators/mutation-delete-resolver-generator.ts

@@ -4,6 +4,7 @@ import {
 } from '../../persistence/persistence.service'
 import { GraphQLFieldResolver } from 'graphql/type/definition'
 import { ApolloContext } from '../../app/api.service'
+import { GraphQLError } from 'graphql/error/GraphQLError'
 
 export class MutationDeleteResolverGenerator {
   constructor(private readonly persistence: PersistenceService) {}
@@ -17,6 +18,25 @@ export class MutationDeleteResolverGenerator {
       context: ApolloContext,
       info,
     ): Promise<Entry> => {
+      try {
+        await this.persistence.findByTypeId(
+          context.gitAdapter,
+          context.getCurrentRef(),
+          typeName,
+          args.id,
+        )
+      } catch (_) {
+        throw new GraphQLError(
+          `No entry of type "${typeName}" with id "${args.id}" exists`,
+          {
+            extensions: {
+              code: 'BAD_USER_INPUT',
+              argumentName: 'id',
+            },
+          },
+        )
+      }
+
       // TODO validate ID to delete is not referenced anywhere
       const deleteResult = await this.persistence.deleteByTypeId(
         context.gitAdapter,

package/src/graphql/resolver-generators/mutation-update.resolver-generator.ts

@@ -4,6 +4,7 @@ import {
 } from '../../persistence/persistence.service'
 import { GraphQLFieldResolver } from 'graphql/type/definition'
 import { ApolloContext } from '../../app/api.service'
+import { GraphQLError } from 'graphql/error/GraphQLError'
 
 export class MutationUpdateResolverGenerator {
   constructor(private readonly persistence: PersistenceService) {}
@@ -17,6 +18,25 @@ export class MutationUpdateResolverGenerator {
       context: ApolloContext,
       info,
     ): Promise<Entry> => {
+      try {
+        await this.persistence.findByTypeId(
+          context.gitAdapter,
+          context.getCurrentRef(),
+          typeName,
+          args.id,
+        )
+      } catch (_) {
+        throw new GraphQLError(
+          `No entry of type "${typeName}" with id "${args.id}" exists`,
+          {
+            extensions: {
+              code: 'BAD_USER_INPUT',
+              argumentName: 'id',
+            },
+          },
+        )
+      }
+
       // TODO validate ID references in payload to assert referenced ID exists and points to correct entry type
       const updateResult = await this.persistence.updateByTypeId(
         context.gitAdapter,

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

@@ -49,7 +49,8 @@ export class SchemaGeneratorService {
     }
     const schemaAnalyzerResult = this.schemaAnalyzer.analyzeSchema(schema)
 
-    const filteredOriginalSchemaString = printSchemaWithDirectives(schema)
+    const filteredOriginalSchemaString =
+      printSchemaWithDirectives(schema) + '\n'
 
     const generatedIdInputTypeStrings =
       this.inputTypeGenerator.generateIdInputTypeStrings(schemaAnalyzerResult)
@@ -61,7 +62,7 @@ export class SchemaGeneratorService {
     const generatedTypeNameQuery =
       this.queriesMutationsGenerator.generateTypeNameQuery()
 
-    let generatedEntryReferenceResolvers: Record<
+    const generatedEntryReferenceResolvers: Record<
       string,
       Record<
         string,
@@ -172,14 +173,16 @@ export class SchemaGeneratorService {
       }
     }
 
+    const typeDefs = [
+      filteredOriginalSchemaString,
+      generatedSchemaString,
+      generatedIdInputTypeStrings.join('\n'),
+      generatedObjectInputTypeStrings.join('\n'),
+      generatedUnionInputTypeStrings.join('\n'),
+    ].filter((typeDef) => typeDef.length > 0)
+
     return {
-      typeDefs: [
-        filteredOriginalSchemaString,
-        generatedSchemaString,
-        generatedIdInputTypeStrings.join('\n'),
-        generatedObjectInputTypeStrings.join('\n'),
-        generatedUnionInputTypeStrings.join('\n'),
-      ],
+      typeDefs: typeDefs,
       resolvers: allGeneratedResolvers,
     }
   }

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

@@ -13,16 +13,18 @@ export class SchemaRootTypeGeneratorService {
       generatedSchemas
         .map((generated) => '  ' + generated.queryAll.schemaString)
         .join('\n') +
+      '\n' +
       generatedSchemas
         .map((generated) => '  ' + generated.queryAllMeta.schemaString)
         .join('\n') +
+      '\n' +
       generatedSchemas
         .map((generated) => '  ' + generated.queryById.schemaString)
         .join('\n') +
       '\n' +
       `  ${typeQuery.schemaString}` +
       '\n' +
-      '}\n' +
+      '}\n\n' +
       'type Mutation {\n' +
       generatedSchemas
         .map((generated) => '  ' + generated.createMutation.schemaString)

package/src/persistence/persistence.service.ts

@@ -1,17 +1,15 @@
-import { v4 as uuidv4 } from 'uuid'
 import { ContentEntry, GitAdapter } from '@commitspark/git-adapter'
+import { GraphQLError } from 'graphql/error/GraphQLError'
 
 export class PersistenceService {
-  constructor() {}
-
   public async getTypeById(
     gitAdapter: GitAdapter,
     commitHash: string,
-    id: ID,
+    id: string,
   ): Promise<string> {
     const allEntries = await gitAdapter.getContentEntries(commitHash)
     const requestedEntry = allEntries.filter(
-      (contentEntry: ContentEntry) => contentEntry.id === (id as string),
+      (contentEntry: ContentEntry) => contentEntry.id === id,
     )[0]
     if (requestedEntry === undefined) {
       throw new Error(`Not found: ${id}`)
@@ -23,11 +21,11 @@ export class PersistenceService {
   public async findById(
     gitAdapter: GitAdapter,
     commitHash: string,
-    id: ID,
+    id: string,
   ): Promise<Entry> {
     const allEntries = await gitAdapter.getContentEntries(commitHash)
     const requestedEntry = allEntries.filter(
-      (contentEntry: ContentEntry) => contentEntry.id === (id as string),
+      (contentEntry: ContentEntry) => contentEntry.id === id,
     )[0]
     if (requestedEntry === undefined) {
       throw new Error(`Not found: ${id}`)
@@ -53,11 +51,11 @@ export class PersistenceService {
     gitAdapter: GitAdapter,
     commitHash: string,
     type: string,
-    id: ID,
+    id: string,
   ): Promise<Entry> {
     const allEntries = await gitAdapter.getContentEntries(commitHash)
     const requestedEntry = allEntries.filter(
-      (contentEntry: ContentEntry) => contentEntry.id === (id as string),
+      (contentEntry: ContentEntry) => contentEntry.id === id,
     )[0]
     if (requestedEntry === undefined || requestedEntry.metadata.type !== type) {
       throw new Error(`Not found: ${type}, ${id}`)
@@ -70,21 +68,32 @@ export class PersistenceService {
     gitAdapter: GitAdapter,
     branch: string,
     commitHash: string,
-    type: string,
+    typeName: string,
+    id: string,
     data: Entry,
     message: string,
   ): Promise<CommitResult> {
-    const id = uuidv4()
+    // TODO expose regex publicly to allow reuse
+    const regex = /^[a-zA-Z\-_]{1,250}$/
+    if (!id.match(regex)) {
+      throw new GraphQLError(`"id" does not match regex "${regex}"`, {
+        extensions: {
+          code: 'BAD_USER_INPUT',
+          argumentName: 'id',
+        },
+      })
+    }
+
     const commit = await gitAdapter.createCommit({
       ref: branch,
       parentSha: commitHash,
       contentEntries: [
         {
           id: id,
-          data: data,
           metadata: {
-            type: type,
+            type: typeName,
           },
+          data: data,
           deletion: false,
         },
       ],
@@ -92,7 +101,6 @@ export class PersistenceService {
     })
 
     return {
-      id,
       ref: commit.ref,
     }
   }
@@ -102,13 +110,13 @@ export class PersistenceService {
     branch: string,
     commitHash: string,
     type: string,
-    id: ID,
+    id: string,
     data: Entry,
     message: string,
   ): Promise<CommitResult> {
     const allEntries = await gitAdapter.getContentEntries(commitHash)
     const requestedEntry = allEntries.filter(
-      (contentEntry: ContentEntry) => contentEntry.id === (id as string),
+      (contentEntry: ContentEntry) => contentEntry.id === id,
     )[0]
     if (requestedEntry === undefined || requestedEntry.metadata.type !== type) {
       throw new Error(`Not found: ${type}, ${id}`)
@@ -122,8 +130,8 @@ export class PersistenceService {
       contentEntries: [
         {
           id: id,
-          data: newData,
           metadata: requestedEntry.metadata,
+          data: newData,
           deletion: false,
         },
       ],
@@ -131,7 +139,6 @@ export class PersistenceService {
     })
 
     return {
-      id,
       ref: commit.ref,
     }
   }
@@ -141,12 +148,12 @@ export class PersistenceService {
     branch: string,
     commitHash: string,
     type: string,
-    id: ID,
+    id: string,
     message: string,
   ): Promise<CommitResult> {
     const allEntries = await gitAdapter.getContentEntries(commitHash)
     const requestedEntry = allEntries.filter(
-      (contentEntry: ContentEntry) => contentEntry.id === (id as string),
+      (contentEntry: ContentEntry) => contentEntry.id === id,
     )[0]
     if (requestedEntry === undefined || requestedEntry.metadata.type !== type) {
       throw new Error(`Not found: ${type}, ${id}`)
@@ -158,8 +165,8 @@ export class PersistenceService {
       contentEntries: [
         {
           id: id,
-          data: {},
           metadata: requestedEntry.metadata,
+          data: {},
           deletion: true,
         },
       ],
@@ -167,17 +174,13 @@ export class PersistenceService {
     })
 
     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/.eslintrc.js

@@ -1,24 +0,0 @@
-module.exports = {
-  parser: '@typescript-eslint/parser',
-  parserOptions: {
-    project: 'tsconfig.json',
-    sourceType: 'module',
-  },
-  plugins: ['@typescript-eslint/eslint-plugin'],
-  extends: [
-    'plugin:@typescript-eslint/recommended',
-    'plugin:prettier/recommended',
-  ],
-  root: true,
-  env: {
-    node: true,
-    jest: true,
-  },
-  ignorePatterns: ['.eslintrc.js'],
-  rules: {
-    '@typescript-eslint/interface-name-prefix': 'off',
-    '@typescript-eslint/explicit-function-return-type': 'off',
-    '@typescript-eslint/explicit-module-boundary-types': 'off',
-    '@typescript-eslint/no-explicit-any': 'off',
-  },
-};

package/.prettierrc

@@ -1,6 +0,0 @@
-{
-  "semi": false,
-  "singleQuote": true,
-  "tabWidth": 2,
-  "trailingComma": "all"
-}

package/tsconfig.build.json

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

package/tsconfig.json

@@ -1,18 +0,0 @@
-{
-  "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

@@ -1,25 +0,0 @@
-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'),
-      },
-    },
-  }
-}