@commitspark/git-adapter-github 0.20.0 → 0.30.0

package/src/github-adapter.ts

@@ -1,51 +1,44 @@
 import { AxiosCacheInstance, CacheAxiosResponse } from 'axios-cache-interceptor'
-import { Commit, CommitDraft, Entry } from '@commitspark/git-adapter'
+import {
+  Commit,
+  CommitDraft,
+  Entry,
+  ErrorCode,
+  GitAdapterError,
+} from '@commitspark/git-adapter'
 import { GitHubRepositoryOptions } from './index'
 import {
-  createBlobContentQuery,
-  createBlobsContentQuery,
+  createSingleBlobContentQuery,
   createCommitMutation,
   createLatestCommitQuery,
-} from './util/graphql-query-factory'
+} from './github-api/graphql-query-factory'
 import { convertEntriesToActions } from './util/entries-to-actions-converter'
 import { getPathEntryFolder, getPathSchema } from './util/path-factory'
-import { createEntriesFromBlobsQueryResponseData } from './util/entry-factory'
-
-export const API_URL = 'https://api.github.com/graphql'
+import { createEntriesFromFileContent } from './util/entry-factory'
+import { handleGraphQLErrors, handleHttpErrors } from './errors'
+import { getEntryContent } from './github-api/get-entry-content'
+import { getFilePaths } from './github-api/get-file-paths'
+import { GITHUB_GRAPHQL_API_URL } from './types'
 
 export const getEntries = async (
   gitRepositoryOptions: GitHubRepositoryOptions,
   axiosCacheInstance: AxiosCacheInstance,
   commitHash: string,
 ): Promise<Entry[]> => {
-  const token = gitRepositoryOptions.accessToken
-  const pathEntryFolder = getPathEntryFolder(gitRepositoryOptions)
-
-  const queryFilesContent = createBlobsContentQuery()
-  const filesContentResponse = await axiosCacheInstance.post(
-    API_URL,
-    {
-      query: queryFilesContent,
-      variables: {
-        repositoryOwner: gitRepositoryOptions.repositoryOwner,
-        repositoryName: gitRepositoryOptions.repositoryName,
-        expression: `${commitHash}:${pathEntryFolder}`,
-      },
-    },
-    {
-      headers: {
-        authorization: `Bearer ${token}`,
-      },
-    },
+  const filenames: string[] = await getFilePaths(
+    gitRepositoryOptions,
+    axiosCacheInstance,
+    commitHash,
   )
 
-  if (!filesContentResponse.data.data.repository?.object?.entries) {
-    return []
-  }
-
-  return createEntriesFromBlobsQueryResponseData(
-    filesContentResponse.data.data.repository.object.entries,
+  const filePathsContentMap = await getEntryContent(
+    gitRepositoryOptions,
+    axiosCacheInstance,
+    commitHash,
+    filenames,
   )
+
+  return createEntriesFromFileContent(gitRepositoryOptions, filePathsContentMap)
 }
 
 export const getSchema = async (
@@ -58,27 +51,44 @@ export const getSchema = async (
   const token = gitRepositoryOptions.accessToken
   const schemaFilePath = getPathSchema(gitRepositoryOptions)
 
-  const queryContent = createBlobContentQuery()
-  const response = await axiosCacheInstance.post(
-    API_URL,
-    {
-      query: queryContent,
-      variables: {
-        repositoryOwner: repositoryOwner,
-        repositoryName: repositoryName,
-        expression: `${commitHash}:${schemaFilePath}`,
+  const queryContent = createSingleBlobContentQuery()
+
+  let response: CacheAxiosResponse | undefined
+  try {
+    response = await axiosCacheInstance.post(
+      GITHUB_GRAPHQL_API_URL,
+      {
+        query: queryContent,
+        variables: {
+          repositoryOwner: repositoryOwner,
+          repositoryName: repositoryName,
+          expression: `${commitHash}:${schemaFilePath}`,
+        },
       },
-    },
-    {
-      headers: {
-        authorization: `Bearer ${token}`,
+      {
+        headers: {
+          authorization: `Bearer ${token}`,
+        },
       },
-    },
-  )
+    )
+  } catch (error) {
+    handleHttpErrors(error)
+  }
+
+  if (!response) {
+    throw new GitAdapterError(
+      ErrorCode.INTERNAL_ERROR,
+      `Failed to fetch schema`,
+    )
+  }
+
+  handleGraphQLErrors(response)
+
   const schema = response.data?.data?.repository?.object?.text
 
   if (!schema) {
-    throw new Error(
+    throw new GitAdapterError(
+      ErrorCode.NOT_FOUND,
       `"${schemaFilePath}" not found in Git repository "${repositoryOwner}/${repositoryName}" at commit "${commitHash}"`,
     )
   }
@@ -95,26 +105,40 @@ export const getLatestCommitHash = async (
 
   const queryLatestCommit = createLatestCommitQuery()
 
-  const response = await axiosCacheInstance.post(
-    API_URL,
-    {
-      query: queryLatestCommit,
-      variables: {
-        repositoryOwner: gitRepositoryOptions.repositoryOwner,
-        repositoryName: gitRepositoryOptions.repositoryName,
-        ref: ref,
+  let response: CacheAxiosResponse | undefined
+  try {
+    response = await axiosCacheInstance.post(
+      GITHUB_GRAPHQL_API_URL,
+      {
+        query: queryLatestCommit,
+        variables: {
+          repositoryOwner: gitRepositoryOptions.repositoryOwner,
+          repositoryName: gitRepositoryOptions.repositoryName,
+          ref: ref,
+        },
       },
-    },
-    {
-      cache: false, // must not use cache, so we always get the branch's current head
-      headers: {
-        authorization: `Bearer ${token}`,
+      {
+        cache: false, // must not use cache, so we always get the branch's current head
+        headers: {
+          authorization: `Bearer ${token}`,
+        },
       },
-    },
-  )
+    )
+  } catch (error) {
+    handleHttpErrors(error)
+  }
+
+  if (!response) {
+    throw new GitAdapterError(
+      ErrorCode.INTERNAL_ERROR,
+      'Failed to fetch latest commit',
+    )
+  }
+  handleGraphQLErrors(response)
 
   if (!response.data.data.repository) {
-    throw new Error(
+    throw new GitAdapterError(
+      ErrorCode.NOT_FOUND,
       `No repository found "${gitRepositoryOptions.repositoryOwner}/${gitRepositoryOptions.repositoryName}"`,
     )
   }
@@ -124,7 +148,10 @@ export const getLatestCommitHash = async (
     response.data.data.repository.object?.oid ??
     undefined
   if (!lastCommit) {
-    throw new Error(`No commit found for ref "${ref}"`)
+    throw new GitAdapterError(
+      ErrorCode.NOT_FOUND,
+      `No commit found for ref "${ref}"`,
+    )
   }
 
   return lastCommit
@@ -144,35 +171,50 @@ export const createCommit = async (
   )
 
   const mutateCommit = createCommitMutation()
-  const response: CacheAxiosResponse = await axiosCacheInstance.post(
-    API_URL,
-    {
-      query: mutateCommit,
-      variables: {
-        repositoryNameWithOwner: `${gitRepositoryOptions.repositoryOwner}/${gitRepositoryOptions.repositoryName}`,
-        branchName: commitDraft.ref,
-        commitMessage: commitDraft.message ?? '-',
-        precedingCommitSha: commitDraft.parentSha,
-        additions: additions,
-        deletions: deletions,
+
+  let response: CacheAxiosResponse | undefined
+  try {
+    response = await axiosCacheInstance.post(
+      GITHUB_GRAPHQL_API_URL,
+      {
+        query: mutateCommit,
+        variables: {
+          repositoryNameWithOwner: `${gitRepositoryOptions.repositoryOwner}/${gitRepositoryOptions.repositoryName}`,
+          branchName: commitDraft.ref,
+          commitMessage: commitDraft.message ?? '-',
+          precedingCommitSha: commitDraft.parentSha,
+          additions: additions,
+          deletions: deletions,
+        },
       },
-    },
-    {
-      cache: false,
-      headers: {
-        authorization: `Bearer ${token}`,
+      {
+        cache: false,
+        headers: {
+          authorization: `Bearer ${token}`,
+        },
       },
-    },
-  )
+    )
+  } catch (error) {
+    handleHttpErrors(error)
+  }
 
-  if (response.data.errors) {
-    throw new Error(JSON.stringify(response.data.errors))
+  if (!response) {
+    throw new GitAdapterError(
+      ErrorCode.INTERNAL_ERROR,
+      `Failed to create commit`,
+    )
   }
 
+  handleGraphQLErrors(response)
+
   const mutationResult = response.data.data.commitCreate
 
   if (mutationResult.errors) {
-    throw new Error(JSON.stringify(mutationResult.errors))
+    const errorMessage = JSON.stringify(mutationResult.errors)
+    throw new GitAdapterError(
+      ErrorCode.BAD_REQUEST,
+      `Failed to create commit: ${errorMessage}`,
+    )
   }
 
   return { ref: mutationResult.commit.oid }

package/src/github-api/get-entry-content.ts

@@ -0,0 +1,76 @@
+import { AxiosCacheInstance, CacheAxiosResponse } from 'axios-cache-interceptor'
+import { GitHubRepositoryOptions } from '../index'
+import { createBlobsContentByFilePathsQuery } from './graphql-query-factory'
+import { GITHUB_GRAPHQL_API_URL, QUERY_BATCH_SIZE } from '../types'
+import { handleGraphQLErrors, handleHttpErrors } from '../errors'
+
+export const getEntryContent = async (
+  gitRepositoryOptions: GitHubRepositoryOptions,
+  axiosCacheInstance: AxiosCacheInstance,
+  commitHash: string,
+  filePaths: string[],
+): Promise<Map<string, string>> => {
+  const filePathsContentMap = new Map<string, string>()
+
+  const { queries, queryFilenameAliasMap } = createBlobsContentByFilePathsQuery(
+    filePaths,
+    commitHash,
+    QUERY_BATCH_SIZE,
+  )
+
+  const requestPromises = []
+  for (const contentQuery of queries) {
+    try {
+      requestPromises.push(
+        axiosCacheInstance
+          .post(
+            GITHUB_GRAPHQL_API_URL,
+            {
+              query: contentQuery,
+              variables: {
+                repositoryOwner: gitRepositoryOptions.repositoryOwner,
+                repositoryName: gitRepositoryOptions.repositoryName,
+              },
+            },
+            {
+              headers: {
+                authorization: `Bearer ${gitRepositoryOptions.accessToken}`,
+              },
+              timeout: 30000,
+            },
+          )
+          .then((contentResponse) =>
+            processContentResponse(
+              filePathsContentMap,
+              queryFilenameAliasMap,
+              contentResponse,
+            ),
+          ),
+      )
+    } catch (error) {
+      handleHttpErrors(error)
+    }
+  }
+  await Promise.all(requestPromises)
+
+  return filePathsContentMap
+}
+
+const processContentResponse = (
+  filePathsContentMap: Map<string, string>,
+  queryFilenameAliasMap: Map<string, string>,
+  contentResponse: CacheAxiosResponse,
+): void => {
+  handleGraphQLErrors(contentResponse)
+  const filesResponseData = contentResponse.data.data.repository as Record<
+    string,
+    { text: string }
+  >
+
+  for (const [queryAlias, fileObject] of Object.entries(filesResponseData)) {
+    filePathsContentMap.set(
+      queryFilenameAliasMap.get(queryAlias) as string, // we assume we received only those files we know about
+      fileObject.text,
+    )
+  }
+}

package/src/github-api/get-file-paths.ts

@@ -0,0 +1,66 @@
+import { GitHubRepositoryOptions } from '../index'
+import { AxiosCacheInstance } from 'axios-cache-interceptor'
+import { ErrorCode, GitAdapterError } from '@commitspark/git-adapter'
+import { getPathEntryFolder } from '../util/path-factory'
+import { handleHttpErrors } from '../errors'
+import { GITHUB_REST_API_URL } from '../types'
+
+export const getFilePaths = async (
+  gitRepositoryOptions: GitHubRepositoryOptions,
+  axiosCacheInstance: AxiosCacheInstance,
+  treeSha: string,
+): Promise<string[]> => {
+  const pathEntryFolder = getPathEntryFolder(gitRepositoryOptions)
+  const { repositoryOwner, repositoryName, accessToken } = gitRepositoryOptions
+
+  // hard limit of 100,000 entries and 7MB response size; see https://docs.github.com/en/rest/git/trees?apiVersion=2022-11-28#get-a-tree
+  const restApiUrl =
+    GITHUB_REST_API_URL +
+    `/repos/${repositoryOwner}/${repositoryName}/git/trees/${treeSha}?recursive=1`
+
+  let response
+  try {
+    response = await axiosCacheInstance.get(restApiUrl, {
+      headers: {
+        Authorization: `Bearer ${accessToken}`,
+        Accept: 'application/vnd.github+json',
+      },
+      timeout: 30000,
+    })
+  } catch (error) {
+    handleHttpErrors(error)
+  }
+
+  if (response === undefined) {
+    throw new GitAdapterError(
+      ErrorCode.INTERNAL_ERROR,
+      'Failed to fetch repository file list.',
+    )
+  }
+
+  const data = response.data as GitHubTreeResponse
+
+  if (data.truncated) {
+    throw new GitAdapterError(
+      ErrorCode.INTERNAL_ERROR,
+      `Too many files in repository.`,
+    )
+  }
+
+  return data.tree
+    .filter(
+      (entry) =>
+        entry.type === 'blob' && entry.path.startsWith(pathEntryFolder),
+    )
+    .map((entry) => entry.path)
+}
+
+interface GitHubTreeResponse {
+  tree: GitHubTreeEntry[]
+  truncated: boolean
+}
+
+interface GitHubTreeEntry {
+  path: string
+  type: 'blob' | 'tree' | 'commit'
+}

package/src/{util → github-api}/graphql-query-factory.ts

@@ -1,18 +1,10 @@
-export function createBlobsContentQuery(): string {
+export function createSingleBlobContentQuery(): string {
   return `
       query ($repositoryOwner: String!, $repositoryName: String!, $expression: String!) { 
         repository(owner: $repositoryOwner, name: $repositoryName) {
           object(expression: $expression) {
-            ... on Tree {
-              entries {
-                name
-                object {
-                  __typename
-                  ... on Blob {
-                    text
-                  }
-                }
-              }
+            ... on Blob {
+              text
             }
           }
         }
@@ -20,18 +12,47 @@ export function createBlobsContentQuery(): string {
     `
 }
 
-export function createBlobContentQuery(): string {
-  return `
-      query ($repositoryOwner: String!, $repositoryName: String!, $expression: String!) { 
-        repository(owner: $repositoryOwner, name: $repositoryName) {
-          object(expression: $expression) {
-            ... on Blob {
-              text
-            }
-          }
+export function createBlobsContentByFilePathsQuery(
+  filePaths: string[],
+  commitHash: string,
+  batchSize: number,
+): { queries: string[]; queryFilenameAliasMap: Map<string, string> } {
+  const queries = []
+  const queryFilenameAliasMap = new Map<string, string>()
+  for (
+    let fileIndex = 0;
+    fileIndex < filePaths.length;
+    fileIndex += batchSize
+  ) {
+    // cut file content query into batches and use GraphQL aliases for maximum throughput in regard to GitHub API limits
+
+    const batchFilenames = filePaths.slice(fileIndex, fileIndex + batchSize)
+
+    let query = `
+      query ($repositoryOwner: String!, $repositoryName: String!) { 
+        repository(owner: $repositoryOwner, name: $repositoryName) {`
+
+    for (const [j, filename] of batchFilenames.entries()) {
+      const fileAliasIndex = fileIndex + j
+      const fileAlias = `file${fileAliasIndex}`
+      // using one query variable per file would significantly blow up query size, which would in turn require a lower
+      // batch size to avoid GitHub erroring out, and in consequence much lower throughput; we therefore use this poor
+      // man's manual escaping of filenames instead and write them directly into the query strings
+      const escapedExpression = JSON.stringify(`${commitHash}:${filename}`)
+      query += `    ${fileAlias}: object(expression: ${escapedExpression}) {
+      ... on Blob {
+          text
         }
       }
-    `
+`
+      queryFilenameAliasMap.set(fileAlias, filename)
+    }
+    query += `  }
+}`
+    queries.push(query)
+  }
+
+  return { queries, queryFilenameAliasMap }
 }
 
 export function createCommitMutation(): string {

package/src/types.ts

@@ -0,0 +1,6 @@
+export const ENTRY_EXTENSION = '.yaml'
+export const PATH_SCHEMA_FILE = 'commitspark/schema/schema.graphql'
+export const PATH_ENTRY_FOLDER = 'commitspark/entries/'
+export const QUERY_BATCH_SIZE = 250
+export const GITHUB_GRAPHQL_API_URL = 'https://api.github.com/graphql'
+export const GITHUB_REST_API_URL = 'https://api.github.com'

package/src/util/entries-to-actions-converter.ts

@@ -2,7 +2,7 @@ import { EntryDraft } from '@commitspark/git-adapter'
 import { stringify } from 'yaml'
 import { AdditionModel } from '../model/addition.model'
 import { DeletionModel } from '../model/deletion.model'
-import { ENTRY_EXTENSION } from './types'
+import { ENTRY_EXTENSION } from '../types'
 
 export function convertEntriesToActions(
   entryDrafts: EntryDraft[],

package/src/util/entry-factory.ts

@@ -1,29 +1,20 @@
 import { parse } from 'yaml'
 import { Entry } from '@commitspark/git-adapter'
-import { ENTRY_EXTENSION } from './types'
+import { ENTRY_EXTENSION } from '../types'
+import { getPathEntryFolder } from './path-factory'
+import { GitHubRepositoryOptions } from '../index'
 
-interface TreeEntry {
-  name: string
-  object: {
-    __typename: string
-    text: string
-  }
-}
-
-export function createEntriesFromBlobsQueryResponseData(
-  entries: TreeEntry[],
+export function createEntriesFromFileContent(
+  gitRepositoryOptions: GitHubRepositoryOptions,
+  filePathContentMap: Map<string, string>,
 ): Entry[] {
-  return entries
-    .filter(
-      (entry: TreeEntry) =>
-        entry.name.endsWith(ENTRY_EXTENSION) &&
-        entry.object['__typename'] === 'Blob',
-    )
-    .map((entry: TreeEntry) => {
-      const fileContent = parse(entry.object.text)
-      const id = entry.name.substring(
-        0,
-        entry.name.length - ENTRY_EXTENSION.length,
+  return Array.from(filePathContentMap)
+    .filter(([filePath]) => filePath.endsWith(ENTRY_EXTENSION))
+    .map(([filePath, content]) => {
+      const fileContent = parse(content)
+      const id = filePath.substring(
+        getPathEntryFolder(gitRepositoryOptions).length, // strip folder path back out
+        filePath.length - ENTRY_EXTENSION.length,
       )
       return {
         id: id,

package/src/util/path-factory.ts

@@ -1,5 +1,5 @@
 import { GitHubRepositoryOptions } from '../index'
-import { PATH_ENTRY_FOLDER, PATH_SCHEMA_FILE } from './types'
+import { PATH_ENTRY_FOLDER, PATH_SCHEMA_FILE } from '../types'
 
 export function getPathSchema(gitRepositoryOptions: GitHubRepositoryOptions) {
   return gitRepositoryOptions.pathSchemaFile ?? PATH_SCHEMA_FILE
@@ -11,8 +11,8 @@ export function getPathEntryFolder(
   const pathEntryFolder =
     gitRepositoryOptions.pathEntryFolder ?? PATH_ENTRY_FOLDER
 
-  if (pathEntryFolder.endsWith('/')) {
-    return pathEntryFolder.substring(0, pathEntryFolder.length - 1)
+  if (!pathEntryFolder.endsWith('/')) {
+    return pathEntryFolder + '/'
   }
 
   return pathEntryFolder

package/dist/cjs/util/graphql-query-factory.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"graphql-query-factory.js","sourceRoot":"","sources":["../../../src/util/graphql-query-factory.ts"],"names":[],"mappings":";;AAAA,0DAoBC;AAED,wDAYC;AAED,oDA+BC;AAED,0DAeC;AApFD,SAAgB,uBAAuB;IACrC,OAAO;;;;;;;;;;;;;;;;;;KAkBJ,CAAA;AACL,CAAC;AAED,SAAgB,sBAAsB;IACpC,OAAO;;;;;;;;;;KAUJ,CAAA;AACL,CAAC;AAED,SAAgB,oBAAoB;IAClC,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KA6BJ,CAAA;AACL,CAAC;AAED,SAAgB,uBAAuB;IACrC,OAAO;;;;;;;;;;;;;KAaJ,CAAA;AACL,CAAC"}

package/dist/cjs/util/types.js

@@ -1,7 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PATH_ENTRY_FOLDER = exports.PATH_SCHEMA_FILE = exports.ENTRY_EXTENSION = void 0;
-exports.ENTRY_EXTENSION = '.yaml';
-exports.PATH_SCHEMA_FILE = 'commitspark/schema/schema.graphql';
-exports.PATH_ENTRY_FOLDER = 'commitspark/entries/';
-//# sourceMappingURL=types.js.map

package/dist/cjs/util/types.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../src/util/types.ts"],"names":[],"mappings":";;;AAAa,QAAA,eAAe,GAAG,OAAO,CAAA;AACzB,QAAA,gBAAgB,GAAG,mCAAmC,CAAA;AACtD,QAAA,iBAAiB,GAAG,sBAAsB,CAAA"}

package/dist/esm/util/graphql-query-factory.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"graphql-query-factory.js","sourceRoot":"","sources":["../../../src/util/graphql-query-factory.ts"],"names":[],"mappings":"AAAA,MAAM,UAAU,uBAAuB;IACrC,OAAO;;;;;;;;;;;;;;;;;;KAkBJ,CAAA;AACL,CAAC;AAED,MAAM,UAAU,sBAAsB;IACpC,OAAO;;;;;;;;;;KAUJ,CAAA;AACL,CAAC;AAED,MAAM,UAAU,oBAAoB;IAClC,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KA6BJ,CAAA;AACL,CAAC;AAED,MAAM,UAAU,uBAAuB;IACrC,OAAO;;;;;;;;;;;;;KAaJ,CAAA;AACL,CAAC"}

package/dist/esm/util/types.js

@@ -1,4 +0,0 @@
-export const ENTRY_EXTENSION = '.yaml';
-export const PATH_SCHEMA_FILE = 'commitspark/schema/schema.graphql';
-export const PATH_ENTRY_FOLDER = 'commitspark/entries/';
-//# sourceMappingURL=types.js.map

package/dist/esm/util/types.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../src/util/types.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,MAAM,eAAe,GAAG,OAAO,CAAA;AACtC,MAAM,CAAC,MAAM,gBAAgB,GAAG,mCAAmC,CAAA;AACnE,MAAM,CAAC,MAAM,iBAAiB,GAAG,sBAAsB,CAAA"}

package/dist/types/util/graphql-query-factory.d.ts

@@ -1,5 +0,0 @@
-export declare function createBlobsContentQuery(): string;
-export declare function createBlobContentQuery(): string;
-export declare function createCommitMutation(): string;
-export declare function createLatestCommitQuery(): string;
-//# sourceMappingURL=graphql-query-factory.d.ts.map

package/dist/types/util/graphql-query-factory.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"graphql-query-factory.d.ts","sourceRoot":"","sources":["../../../src/util/graphql-query-factory.ts"],"names":[],"mappings":"AAAA,wBAAgB,uBAAuB,IAAI,MAAM,CAoBhD;AAED,wBAAgB,sBAAsB,IAAI,MAAM,CAY/C;AAED,wBAAgB,oBAAoB,IAAI,MAAM,CA+B7C;AAED,wBAAgB,uBAAuB,IAAI,MAAM,CAehD"}

package/dist/types/util/types.d.ts

@@ -1,4 +0,0 @@
-export declare const ENTRY_EXTENSION = ".yaml";
-export declare const PATH_SCHEMA_FILE = "commitspark/schema/schema.graphql";
-export declare const PATH_ENTRY_FOLDER = "commitspark/entries/";
-//# sourceMappingURL=types.d.ts.map

package/dist/types/util/types.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/util/types.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,eAAe,UAAU,CAAA;AACtC,eAAO,MAAM,gBAAgB,sCAAsC,CAAA;AACnE,eAAO,MAAM,iBAAiB,yBAAyB,CAAA"}

package/src/util/types.ts

@@ -1,3 +0,0 @@
-export const ENTRY_EXTENSION = '.yaml'
-export const PATH_SCHEMA_FILE = 'commitspark/schema/schema.graphql'
-export const PATH_ENTRY_FOLDER = 'commitspark/entries/'