@things-factory/operato-codelingua 8.0.0-beta.1 → 8.0.0-beta.4

package/server/controllers/github-controller.ts

@@ -1,98 +0,0 @@
-import fetch, { Response } from 'node-fetch'
-
-const GITHUB_API_URL = 'https://api.github.com'
-
-const fetchOptions = (token: string) => ({
-  headers: {
-    'Content-Type': 'application/json',
-    Authorization: `token ${token}`
-  }
-})
-
-const handleFetchError = (response: Response, action: string) => {
-  if (!response.ok) {
-    console.error(`Failed to ${action}:`, response.statusText)
-    throw new Error(`Failed to ${action}`)
-  }
-}
-
-const getWebhooks = async (repoFullName: string, token: string): Promise<any[]> => {
-  const response: Response = await fetch(`${GITHUB_API_URL}/repos/${repoFullName}/hooks`, fetchOptions(token))
-  handleFetchError(response, 'fetch webhooks')
-  return response.json()
-}
-
-const webhookExists = async (
-  repoFullName: string,
-  webhookUrl: string,
-  token: string
-): Promise<{ exists: boolean; id?: number }> => {
-  try {
-    const hooks: any[] = await getWebhooks(repoFullName, token)
-    const hook = hooks.find((hook: any) => hook.config.url === webhookUrl)
-    return hook ? { exists: true, id: hook.id } : { exists: false }
-  } catch (error) {
-    console.error('Error checking webhook existence:', error)
-    return { exists: false }
-  }
-}
-
-export const postGitHubComment = async (repoFullName: string, commitId: string, comment: string): Promise<void> => {
-  try {
-    const response: Response = await fetch(`${GITHUB_API_URL}/repos/${repoFullName}/commits/${commitId}/comments`, {
-      method: 'POST',
-      ...fetchOptions(process.env.GITHUB_API_KEY!),
-      body: JSON.stringify({ body: comment })
-    })
-    handleFetchError(response, 'post GitHub comment')
-  } catch (error) {
-    console.error('Error posting GitHub comment:', error)
-  }
-}
-
-export const registerWebhook = async (accessToken: string, repoFullName: string, webhookUrl: string) => {
-  const { exists } = await webhookExists(repoFullName, webhookUrl, accessToken)
-  if (exists) {
-    console.log('Webhook already registered.')
-    return
-  }
-
-  try {
-    const response: Response = await fetch(`${GITHUB_API_URL}/repos/${repoFullName}/hooks`, {
-      method: 'POST',
-      ...fetchOptions(accessToken),
-      body: JSON.stringify({
-        name: 'web',
-        active: true,
-        events: ['push'],
-        config: {
-          url: webhookUrl,
-          content_type: 'json'
-        }
-      })
-    })
-    handleFetchError(response, 'register webhook')
-    console.log('Webhook registered successfully.')
-  } catch (error) {
-    console.error('Error registering webhook:', error)
-  }
-}
-
-export const unregisterWebhook = async (accessToken: string, repoFullName: string, webhookUrl: string) => {
-  const { exists, id } = await webhookExists(repoFullName, webhookUrl, accessToken)
-  if (!exists || !id) {
-    console.log('Webhook not found.')
-    return
-  }
-
-  try {
-    const deleteResponse: Response = await fetch(`${GITHUB_API_URL}/repos/${repoFullName}/hooks/${id}`, {
-      method: 'DELETE',
-      ...fetchOptions(accessToken)
-    })
-    handleFetchError(deleteResponse, 'unregister webhook')
-    console.log('Webhook unregistered successfully.')
-  } catch (error) {
-    console.error('Error unregistering webhook:', error)
-  }
-}

package/server/index.ts

@@ -1,7 +0,0 @@
-import './routes'
-
-export * from './migrations'
-export * from './middlewares'
-export * from './service'
-
-/* github webhook 이 등록되지 않았다면, 웹훅을 등록한다. */

package/server/middlewares/index.ts

@@ -1,3 +0,0 @@
-export function initMiddlewares(app) {
-  /* can add middlewares into app */
-}

package/server/migrations/index.ts

@@ -1,9 +0,0 @@
-const glob = require('glob')
-const path = require('path')
-
-export var migrations = []
-
-glob.sync(path.resolve(__dirname, '.', '**', '*.js')).forEach(function(file) {
-  if (file.indexOf('index.js') !== -1) return
-  migrations = migrations.concat(Object.values(require(path.resolve(file))) || [])
-})

package/server/routers/github-webhook-router.ts

@@ -1,45 +0,0 @@
-import Router from 'koa-router'
-import { codereviewCompletion } from '@things-factory/codelingua'
-
-import { postGitHubComment } from '../controllers/github-controller'
-import { getRepository } from '@things-factory/shell'
-import { GitProject } from '../service/git-project/git-project'
-
-export const githubWebhookRouter = new Router()
-
-githubWebhookRouter.post('/github-webhook/:projectId', async (context, next) => {
-  const { payload, head_commit } = context.request.body
-  const { commitDiff } = head_commit.diff
-  // const { commits, pull_request } = payload
-  const projectId = context.params.projectId
-
-  const project = await getRepository(GitProject).findOne({
-    where: {
-      id: projectId
-    }
-  })
-
-  if (!project) {
-    context.status = 404
-    context.body = 'Project not found'
-    return
-  }
-
-  // for (const commit of commits) {
-  //   const codeDiff = `diff of the changed code here` // 실제 diff 데이터를 가져오는 로직 필요
-  //   const reviewFeedback = await codereviewCompletion(codeDiff)
-  //   const pullNumber = pull_request.number // 풀 리퀘스트 번호를 받아옴
-  //   await postGitHubComment(project.repositoryUrl, pullNumber, reviewFeedback)
-  // }
-
-  const reviewFeedback = await codereviewCompletion(commitDiff)
-
-  await postGitHubComment(
-    context.request.body.repository.full_name,
-    context.request.body.head_commit.id,
-    reviewFeedback
-  )
-
-  context.status = 200
-  context.body = 'Success'
-})

package/server/routes.ts

@@ -1,30 +0,0 @@
-import { githubWebhookRouter } from './routers/github-webhook-router'
-
-process.on('bootstrap-module-global-public-route' as any, (app, globalPublicRouter) => {
-  /*
-   * can add global public routes to application (auth not required, tenancy not required)
-   *
-   * ex) routes.get('/path', async(context, next) => {})
-   * ex) routes.post('/path', async(context, next) => {})
-   */
-
-  globalPublicRouter.use('', githubWebhookRouter.routes(), githubWebhookRouter.allowedMethods())
-})
-
-process.on('bootstrap-module-global-private-route' as any, (app, globalPrivateRouter) => {
-  /*
-   * can add global private routes to application (auth required, tenancy not required)
-   */
-})
-
-process.on('bootstrap-module-domain-public-route' as any, (app, domainPublicRouter) => {
-  /*
-   * can add domain public routes to application (auth not required, tenancy required)
-   */
-})
-
-process.on('bootstrap-module-domain-private-route' as any, (app, domainPrivateRouter) => {
-  /*
-   * can add domain private routes to application (auth required, tenancy required)
-   */
-})

package/server/service/git-project/git-project-mutation.ts

@@ -1,179 +0,0 @@
-import { Resolver, Mutation, Arg, Ctx, Directive } from 'type-graphql'
-import { In } from 'typeorm'
-
-import { GitProject, GitProjectStatus } from './git-project'
-import { NewGitProject, GitProjectPatch } from './git-project-type'
-import { registerWebhook, unregisterWebhook } from '../../controllers/github-controller'
-
-@Resolver(GitProject)
-export class GitProjectMutation {
-  @Directive('@transaction')
-  @Mutation(returns => GitProject, { description: 'To create new GitProject' })
-  async createGitProject(
-    @Arg('gitProject') gitProject: NewGitProject,
-    @Ctx() context: ResolverContext
-  ): Promise<GitProject> {
-    const { domain, user, tx } = context.state
-
-    const result = await tx.getRepository(GitProject).save({
-      ...gitProject,
-      domain,
-      creator: user,
-      updater: user
-    })
-
-    return result
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => GitProject, { description: 'To modify GitProject information' })
-  async updateGitProject(
-    @Arg('id') id: string,
-    @Arg('patch') patch: GitProjectPatch,
-    @Ctx() context: ResolverContext
-  ): Promise<GitProject> {
-    const { domain, user, tx } = context.state
-
-    const repository = tx.getRepository(GitProject)
-    const gitProject = await repository.findOne({
-      where: { domain: { id: domain.id }, id }
-    })
-
-    const result = await repository.save({
-      ...gitProject,
-      ...patch,
-      updater: user
-    })
-
-    return result
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => [GitProject], { description: "To modify multiple GitProjects' information" })
-  async updateMultipleGitProject(
-    @Arg('patches', type => [GitProjectPatch]) patches: GitProjectPatch[],
-    @Ctx() context: ResolverContext
-  ): Promise<GitProject[]> {
-    const { domain, user, tx } = context.state
-
-    let results = []
-    const _createRecords = patches.filter((patch: any) => patch.cuFlag.toUpperCase() === '+')
-    const _updateRecords = patches.filter((patch: any) => patch.cuFlag.toUpperCase() === 'M')
-    const gitProjectRepo = tx.getRepository(GitProject)
-
-    if (_createRecords.length > 0) {
-      for (let i = 0; i < _createRecords.length; i++) {
-        const newRecord = _createRecords[i]
-
-        const result = await gitProjectRepo.save({
-          ...newRecord,
-          domain,
-          creator: user,
-          updater: user
-        })
-
-        results.push({ ...result, cuFlag: '+' })
-      }
-    }
-
-    if (_updateRecords.length > 0) {
-      for (let i = 0; i < _updateRecords.length; i++) {
-        const updateRecord = _updateRecords[i]
-        const gitProject = await gitProjectRepo.findOneBy({ id: updateRecord.id })
-
-        const result = await gitProjectRepo.save({
-          ...gitProject,
-          ...updateRecord,
-          updater: user
-        })
-
-        results.push({ ...result, cuFlag: 'M' })
-      }
-    }
-
-    return results
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => Boolean, { description: 'To delete GitProject' })
-  async deleteGitProject(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<boolean> {
-    const { domain, tx } = context.state
-
-    await tx.getRepository(GitProject).delete({ domain: { id: domain.id }, id })
-
-    return true
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => Boolean, { description: 'To delete multiple GitProjects' })
-  async deleteGitProjects(
-    @Arg('ids', type => [String]) ids: string[],
-    @Ctx() context: ResolverContext
-  ): Promise<boolean> {
-    const { domain, tx } = context.state
-
-    await tx.getRepository(GitProject).delete({
-      domain: { id: domain.id },
-      id: In(ids)
-    })
-
-    return true
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => Boolean, { description: 'To import multiple GitProjects' })
-  async importGitProjects(
-    @Arg('gitProjects', type => [GitProjectPatch]) gitProjects: GitProjectPatch[],
-    @Ctx() context: ResolverContext
-  ): Promise<boolean> {
-    const { domain, tx } = context.state
-
-    await Promise.all(
-      gitProjects.map(async (gitProject: GitProjectPatch) => {
-        const createdGitProject: GitProject = await tx.getRepository(GitProject).save({ domain, ...gitProject })
-      })
-    )
-
-    return true
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => Boolean, { description: 'To register GitHub webhook' })
-  async registerGithubWebhook(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<boolean> {
-    const { domain, tx } = context.state
-
-    const repository = tx.getRepository(GitProject)
-    const gitProject = await repository.findOne({ where: { domain: { id: domain.id }, id } })
-
-    if (!gitProject) {
-      throw new Error('GitProject not found')
-    }
-
-    const webhook = await registerWebhook(gitProject.apiKey, gitProject.name, gitProject.webhookUrl)
-
-    gitProject.state = GitProjectStatus.REGISTERED
-    await repository.save(gitProject)
-
-    return true
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => Boolean, { description: 'To unregister GitHub webhook' })
-  async unregisterGithubWebhook(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<boolean> {
-    const { domain, tx } = context.state
-
-    const repository = tx.getRepository(GitProject)
-    const gitProject = await repository.findOne({ where: { domain: { id: domain.id }, id } })
-
-    if (!gitProject) {
-      throw new Error('GitProject not found')
-    }
-
-    await unregisterWebhook(gitProject.apiKey, gitProject.name, gitProject.webhookUrl)
-
-    gitProject.state = GitProjectStatus.READY
-    await repository.save(gitProject)
-
-    return true
-  }
-}

package/server/service/git-project/git-project-query.ts

@@ -1,48 +0,0 @@
-import { Resolver, Query, FieldResolver, Root, Args, Arg, Ctx, Directive } from 'type-graphql'
-import { Domain, getQueryBuilderFromListParams, getRepository, ListParam } from '@things-factory/shell'
-import { User } from '@things-factory/auth-base'
-import { GitProject } from './git-project'
-import { GitProjectList } from './git-project-type'
-
-@Resolver(GitProject)
-export class GitProjectQuery {
-  @Query(returns => GitProject!, { nullable: true, description: 'To fetch a GitProject' })
-  async gitProject(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<GitProject> {
-    const { domain } = context.state
-
-    return await getRepository(GitProject).findOne({
-      where: { domain: { id: domain.id }, id }
-    })
-  }
-
-  @Query(returns => GitProjectList, { description: 'To fetch multiple GitProjects' })
-  async gitProjects(@Args(type => ListParam) params: ListParam, @Ctx() context: ResolverContext): Promise<GitProjectList> {
-    const { domain } = context.state
-
-    const queryBuilder = getQueryBuilderFromListParams({
-      domain,
-      params,
-      repository: await getRepository(GitProject),
-      searchables: ['name', 'description']
-    })
-
-    const [items, total] = await queryBuilder.getManyAndCount()
-
-    return { items, total }
-  }
-
-  @FieldResolver(type => Domain)
-  async domain(@Root() gitProject: GitProject): Promise<Domain> {
-    return gitProject.domainId && (await getRepository(Domain).findOneBy({ id: gitProject.domainId }))
-  }
-
-  @FieldResolver(type => User)
-  async updater(@Root() gitProject: GitProject): Promise<User> {
-    return gitProject.updaterId && (await getRepository(User).findOneBy({ id: gitProject.updaterId }))
-  }
-
-  @FieldResolver(type => User)
-  async creator(@Root() gitProject: GitProject): Promise<User> {
-    return gitProject.creatorId && (await getRepository(User).findOneBy({ id: gitProject.creatorId }))
-  }
-}

package/server/service/git-project/git-project-type.ts

@@ -1,76 +0,0 @@
-import type { FileUpload } from 'graphql-upload/GraphQLUpload.js'
-import GraphQLUpload from 'graphql-upload/GraphQLUpload.js'
-import { ObjectType, Field, InputType, Int, ID, registerEnumType } from 'type-graphql'
-
-import { ObjectRef, ScalarObject } from '@things-factory/shell'
-
-import { GitProject, GitProjectStatus, GitProjectLanguage } from './git-project'
-
-@InputType()
-export class NewGitProject {
-  @Field()
-  name: string
-
-  @Field({ nullable: true })
-  description?: string
-
-  @Field({ nullable: true })
-  repositoryUrl?: string
-
-  @Field({ nullable: true })
-  apiKey?: string
-
-  @Field(type => GitProjectLanguage, { nullable: true })
-  language?: GitProjectLanguage
-
-  @Field(type => GitProjectStatus, { nullable: true })
-  state?: GitProjectStatus
-
-  @Field({ nullable: true })
-  active?: boolean
-
-  @Field({ nullable: true })
-  params?: string
-}
-
-@InputType()
-export class GitProjectPatch {
-  @Field(type => ID, { nullable: true })
-  id?: string
-
-  @Field({ nullable: true })
-  name?: string
-
-  @Field({ nullable: true })
-  description?: string
-
-  @Field({ nullable: true })
-  repositoryUrl?: string
-
-  @Field({ nullable: true })
-  webhookUrl?: string
-
-  @Field({ nullable: true })
-  apiKey?: string
-
-  @Field(type => GitProjectLanguage, { nullable: true })
-  language?: GitProjectLanguage
-
-  @Field(type => GitProjectStatus, { nullable: true })
-  state?: GitProjectStatus
-
-  @Field({ nullable: true })
-  active?: boolean
-
-  @Field({ nullable: true })
-  cuFlag?: string
-}
-
-@ObjectType()
-export class GitProjectList {
-  @Field(type => [GitProject])
-  items: GitProject[]
-
-  @Field(type => Int)
-  total: number
-}

package/server/service/git-project/git-project.ts

@@ -1,114 +0,0 @@
-import {
-  CreateDateColumn,
-  UpdateDateColumn,
-  Entity,
-  Index,
-  Column,
-  RelationId,
-  ManyToOne,
-  PrimaryGeneratedColumn
-} from 'typeorm'
-import { ObjectType, Field, Int, ID, registerEnumType } from 'type-graphql'
-
-import { Domain } from '@things-factory/shell'
-import { User } from '@things-factory/auth-base'
-
-export enum GitProjectStatus {
-  REGISTERED = 'REGISTERED',
-  READY = 'READY'
-}
-
-registerEnumType(GitProjectStatus, {
-  name: 'GitProjectStatus',
-  description: 'state enumeration of a gitProject'
-})
-
-export enum GitProjectLanguage {
-  javascript = 'javascript',
-  typescript = 'typescript',
-  java = 'java',
-  python = 'python',
-  c = 'c',
-  cpp = 'cpp'
-}
-
-registerEnumType(GitProjectLanguage, {
-  name: 'GitProjectLanguage',
-  description: 'language enumeration of a gitProject'
-})
-
-@Entity()
-@Index('ix_git_project_0', (gitProject: GitProject) => [gitProject.domain, gitProject.name], {
-  unique: true
-})
-@ObjectType({ description: 'Entity for GitProject' })
-export class GitProject {
-  @PrimaryGeneratedColumn('uuid')
-  @Field(type => ID)
-  readonly id: string
-
-  @ManyToOne(type => Domain)
-  @Field({ nullable: true })
-  domain?: Domain
-
-  @RelationId((gitProject: GitProject) => gitProject.domain)
-  domainId?: string
-
-  @Column()
-  @Field({ nullable: true })
-  name?: string
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  description?: string
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  repositoryUrl?: string
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  language?: GitProjectLanguage
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  apiKey?: string
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  active?: boolean
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  state?: GitProjectStatus
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  params?: string
-
-  @CreateDateColumn()
-  @Field({ nullable: true })
-  createdAt?: Date
-
-  @UpdateDateColumn()
-  @Field({ nullable: true })
-  updatedAt?: Date
-
-  @ManyToOne(type => User, { nullable: true })
-  @Field(type => User, { nullable: true })
-  creator?: User
-
-  @RelationId((gitProject: GitProject) => gitProject.creator)
-  creatorId?: string
-
-  @ManyToOne(type => User, { nullable: true })
-  @Field(type => User, { nullable: true })
-  updater?: User
-
-  @RelationId((gitProject: GitProject) => gitProject.updater)
-  updaterId?: string
-
-  get webhookUrl(): string {
-    return `https://codelingua.hatiolab.com/github-webhook/${this.id}`
-  }
-}

package/server/service/git-project/index.ts

@@ -1,7 +0,0 @@
-import { GitProject } from './git-project'
-import { GitProjectQuery } from './git-project-query'
-import { GitProjectMutation } from './git-project-mutation'
-
-export const entities = [GitProject]
-export const resolvers = [GitProjectQuery, GitProjectMutation]
-export const subscribers = []

package/server/service/index.ts

@@ -1,21 +0,0 @@
-/* EXPORT ENTITY TYPES */
-export * from './git-project/git-project'
-
-/* IMPORT ENTITIES AND RESOLVERS */
-import {
-  entities as GitProjectEntities,
-  resolvers as GitProjectResolvers,
-  subscribers as GitProjectSubscribers
-} from './git-project'
-
-export const entities = [
-  /* ENTITIES */
-  ...GitProjectEntities
-]
-
-export const schema = {
-  resolverClasses: [
-    /* RESOLVER CLASSES */
-    ...GitProjectResolvers
-  ]
-}

package/server/tsconfig.json

@@ -1,9 +0,0 @@
-{
-  "extends": "../../tsconfig-base.json",
-  "compilerOptions": {
-    "outDir": "../dist-server",
-    "baseUrl": "./"
-  },
-  "include": ["./**/*"],
-  "exclude": ["**/*.spec.ts"]
-}