@things-factory/oauth2-client 5.0.7 → 6.0.0-alpha.0

package/server/service/index.ts

@@ -0,0 +1,17 @@
+/* IMPORT ENTITIES AND RESOLVERS */
+import { entities as Oauth2ClientEntities, resolvers as Oauth2ClientResolvers } from './oauth2-client'
+
+/* EXPORT ENTITY TYPES */
+export * from './oauth2-client/oauth2-client'
+
+export const entities = [
+  /* ENTITIES */
+  ...Oauth2ClientEntities
+]
+
+export const schema = {
+  resolverClasses: [
+    /* RESOLVER CLASSES */
+    ...Oauth2ClientResolvers
+  ]
+}

package/server/service/oauth2-client/index.ts

@@ -0,0 +1,6 @@
+import { Oauth2Client } from './oauth2-client'
+import { Oauth2ClientQuery } from './oauth2-client-query'
+import { Oauth2ClientMutation } from './oauth2-client-mutation'
+
+export const entities = [Oauth2Client]
+export const resolvers = [Oauth2ClientQuery, Oauth2ClientMutation]

package/server/service/oauth2-client/oauth2-client-mutation.ts

@@ -0,0 +1,188 @@
+import ClientOAuth2 from 'client-oauth2'
+import crypto from 'crypto'
+import { Arg, Ctx, Directive, Mutation, Resolver } from 'type-graphql'
+import { In } from 'typeorm'
+
+import { config } from '@things-factory/env'
+
+import { Oauth2Client } from './oauth2-client'
+import { NewOauth2Client, Oauth2ClientPatch } from './oauth2-client-type'
+
+const protocol: string = config.get('protocol')
+
+@Resolver(Oauth2Client)
+export class Oauth2ClientMutation {
+  @Directive('@transaction')
+  @Mutation(returns => Oauth2Client, { description: 'To create new Oauth2Client' })
+  async createOauth2Client(
+    @Arg('oauth2Client') oauth2Client: NewOauth2Client,
+    @Ctx() context: ResolverContext
+  ): Promise<Oauth2Client> {
+    const { origin } = context
+    const { domain, user, tx } = context.state
+
+    let url: URL = new URL(origin)
+    url.protocol = protocol || url.protocol
+    url.pathname = '/oauth2-client/callback'
+
+    return await tx.getRepository(Oauth2Client).save({
+      ...oauth2Client,
+      callbackUrl: oauth2Client.callbackUrl || url.href,
+      domain,
+      creator: user,
+      updater: user
+    })
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => Oauth2Client, { description: 'To modify Oauth2Client information' })
+  async updateOauth2Client(
+    @Arg('id') id: string,
+    @Arg('patch') patch: Oauth2ClientPatch,
+    @Ctx() context: ResolverContext
+  ): Promise<Oauth2Client> {
+    const { domain, user, tx } = context.state
+
+    const repository = tx.getRepository(Oauth2Client)
+    const oauth2Client = await repository.findOne({
+      where: { domain: { id: domain.id }, id }
+    })
+
+    return await repository.save({
+      ...oauth2Client,
+      ...patch,
+      updater: user
+    })
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => Boolean, { description: 'To delete Oauth2Client' })
+  async deleteOauth2Client(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<boolean> {
+    const { domain, tx } = context.state
+
+    await tx.getRepository(Oauth2Client).delete({ domain: { id: domain.id }, id })
+
+    return true
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => Boolean, { description: 'To delete multiple Oauth2Clients' })
+  async deleteOauth2Clients(
+    @Arg('ids', type => [String]) ids: string[],
+    @Ctx() context: ResolverContext
+  ): Promise<boolean> {
+    const { domain, tx } = context.state
+
+    await tx.getRepository(Oauth2Client).delete({
+      domain: { id: domain.id },
+      id: In(ids)
+    })
+
+    return true
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => Boolean, { description: 'To import multiple Oauth2Clients' })
+  async importOauth2Clients(
+    @Arg('oauth2Clients', type => [Oauth2ClientPatch]) oauth2Clients: Oauth2ClientPatch[],
+    @Ctx() context: ResolverContext
+  ): Promise<boolean> {
+    const { domain, tx } = context.state
+
+    await Promise.all(
+      oauth2Clients.map(async (oauth2Client: Oauth2ClientPatch) => {
+        const createdOauth2Client: Oauth2Client = await tx.getRepository(Oauth2Client).save({ domain, ...oauth2Client })
+      })
+    )
+
+    return true
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => String, { description: 'To get oauth2 auth URL' })
+  async getOauth2AuthUrl(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<string> {
+    const { tx } = context.state
+    const repository = tx.getRepository(Oauth2Client)
+    const oauth2Client = await repository.findOneBy({ id })
+
+    const {
+      grantType,
+      clientId,
+      clientSecret,
+      callbackUrl,
+      accessTokenUrl: accessTokenUri,
+      authUrl: authorizationUri,
+      scopes
+    } = oauth2Client
+
+    if (grantType !== 'code') {
+      throw new Error(`unsupported grant type: ${grantType}`)
+    }
+
+    const state = crypto.randomBytes(16).toString('hex')
+    await repository.save({
+      ...oauth2Client,
+      state
+    })
+
+    var auth = new ClientOAuth2({
+      clientId,
+      clientSecret,
+      accessTokenUri,
+      authorizationUri,
+      redirectUri: callbackUrl || `${context.origin}/oauth2-client/callback`,
+      scopes: scopes?.split(' ') || [],
+      state
+    })
+
+    return await (auth[grantType] as any).getUri()
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => Oauth2Client, { description: 'To refresh oauth2 access token' })
+  async refreshOauth2AccessToken(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<Oauth2Client> {
+    const { tx } = context.state
+    const repository = tx.getRepository(Oauth2Client)
+    const oauth2Client = await repository.findOneBy({ id })
+
+    const {
+      clientId,
+      clientSecret,
+      accessTokenUrl: accessTokenUri,
+      authUrl: authorizationUri,
+      scopes,
+      tokenType,
+      accessToken,
+      refreshToken
+    } = oauth2Client
+
+    if (!refreshToken) {
+      throw new Error('refreshToken not found')
+    }
+
+    var auth = new ClientOAuth2({
+      clientId,
+      clientSecret,
+      accessTokenUri,
+      authorizationUri,
+      scopes: scopes?.split(' ')
+    })
+
+    try {
+      var token = await auth.createToken(accessToken, refreshToken, tokenType, {}).refresh()
+    } catch (err) {
+      throw err
+    }
+
+    const { accessToken: newAccessToken, refreshToken: newRefreshToken, tokenType: newTokenType, data } = token
+    const expires = data?.expires_in ? token.expiresIn(data?.expires_in as any) : null
+
+    return await repository.save({
+      ...oauth2Client,
+      accessToken: newAccessToken,
+      refreshToken: newRefreshToken,
+      tokenType: newTokenType,
+      expires
+    })
+  }
+}

package/server/service/oauth2-client/oauth2-client-query.ts

@@ -0,0 +1,50 @@
+import { Arg, Args, Ctx, FieldResolver, Query, Resolver, Root } from 'type-graphql'
+
+import { User } from '@things-factory/auth-base'
+import { Domain, getQueryBuilderFromListParams, getRepository, ListParam } from '@things-factory/shell'
+
+import { Oauth2Client } from './oauth2-client'
+import { Oauth2ClientList } from './oauth2-client-type'
+
+@Resolver(Oauth2Client)
+export class Oauth2ClientQuery {
+  @Query(returns => Oauth2Client!, { nullable: true, description: 'To fetch a Oauth2Client' })
+  async oauth2Client(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<Oauth2Client> {
+    const { domain } = context.state
+
+    return await getRepository(Oauth2Client).findOne({
+      where: { domain: { id: domain.id }, id }
+    })
+  }
+
+  @Query(returns => Oauth2ClientList, { description: 'To fetch multiple Oauth2Clients' })
+  async oauth2Clients(@Args() params: ListParam, @Ctx() context: ResolverContext): Promise<Oauth2ClientList> {
+    const { domain } = context.state
+
+    const queryBuilder = getQueryBuilderFromListParams({
+      domain,
+      params,
+      repository: await getRepository(Oauth2Client),
+      searchables: ['name', 'description']
+    })
+
+    const [items, total] = await queryBuilder.getManyAndCount()
+
+    return { items, total }
+  }
+
+  @FieldResolver(type => Domain)
+  async domain(@Root() oauth2Client: Oauth2Client): Promise<Domain> {
+    return await getRepository(Domain).findOneBy({ id: oauth2Client.domainId })
+  }
+
+  @FieldResolver(type => User)
+  async updater(@Root() oauth2Client: Oauth2Client): Promise<User> {
+    return await getRepository(User).findOneBy({ id: oauth2Client.updaterId })
+  }
+
+  @FieldResolver(type => User)
+  async creator(@Root() oauth2Client: Oauth2Client): Promise<User> {
+    return await getRepository(User).findOneBy({ id: oauth2Client.creatorId })
+  }
+}

package/server/service/oauth2-client/oauth2-client-type.ts

@@ -0,0 +1,126 @@
+import { Field, InputType, Int, ObjectType } from 'type-graphql'
+
+import { Oauth2Client } from './oauth2-client'
+
+@InputType()
+export class NewOauth2Client {
+  @Field()
+  name: string
+
+  @Field({ nullable: true })
+  description?: string
+
+  @Field({ nullable: true })
+  icon?: string
+
+  @Field({ nullable: true })
+  grantType?: string
+
+  @Field({ nullable: true })
+  clientId?: string
+
+  @Field({ nullable: true })
+  clientSecret?: string
+
+  @Field({ nullable: true })
+  callbackUrl?: string
+
+  @Field({ nullable: true })
+  authUrl?: string
+
+  @Field({ nullable: true })
+  accessTokenUrl?: string
+
+  @Field({ nullable: true })
+  webhook?: string
+
+  @Field({ nullable: true })
+  username?: string
+
+  @Field({ nullable: true })
+  password?: string
+
+  @Field({ nullable: true })
+  codeChallengeMethod?: string
+
+  @Field({ nullable: true })
+  codeVerifier?: string
+
+  @Field({ nullable: true })
+  scopes?: string
+
+  @Field({ nullable: true })
+  accessToken?: string
+
+  @Field({ nullable: true })
+  refreshToken?: string
+
+  @Field({ nullable: true })
+  jwtToken?: string
+}
+
+@InputType()
+export class Oauth2ClientPatch {
+  @Field({ nullable: true })
+  name?: string
+
+  @Field({ nullable: true })
+  description?: string
+
+  @Field({ nullable: true })
+  icon?: string
+
+  @Field({ nullable: true })
+  grantType?: string
+
+  @Field({ nullable: true })
+  clientId?: string
+
+  @Field({ nullable: true })
+  clientSecret?: string
+
+  @Field({ nullable: true })
+  callbackUrl?: string
+
+  @Field({ nullable: true })
+  authUrl?: string
+
+  @Field({ nullable: true })
+  accessTokenUrl?: string
+
+  @Field({ nullable: true })
+  webhook?: string
+
+  @Field({ nullable: true })
+  username?: string
+
+  @Field({ nullable: true })
+  password?: string
+
+  @Field({ nullable: true })
+  codeChallengeMethod?: string
+
+  @Field({ nullable: true })
+  codeVerifier?: string
+
+  @Field({ nullable: true })
+  scopes?: string
+
+  @Field({ nullable: true })
+  accessToken?: string
+
+  @Field({ nullable: true })
+  refreshToken?: string
+
+  @Field({ nullable: true })
+  jwtToken?: string
+}
+
+@ObjectType()
+export class Oauth2ClientList {
+  @Field(type => [Oauth2Client])
+  items: Oauth2Client[]
+
+  @Field(type => Int)
+  total: number
+}

package/server/service/oauth2-client/oauth2-client.ts

@@ -0,0 +1,193 @@
+import { Field, ID, ObjectType } from 'type-graphql'
+import {
+  Column,
+  CreateDateColumn,
+  Entity,
+  Index,
+  ManyToOne,
+  PrimaryGeneratedColumn,
+  RelationId,
+  UpdateDateColumn
+} from 'typeorm'
+
+import { User } from '@things-factory/auth-base'
+import { Domain } from '@things-factory/shell'
+
+@Entity()
+@Index('ix_oauth2_client_0', (oauth2Client: Oauth2Client) => [oauth2Client.domain, oauth2Client.name], { unique: true })
+@ObjectType({ description: 'Entity for Oauth2Client' })
+export class Oauth2Client {
+  @PrimaryGeneratedColumn('uuid')
+  @Field(type => ID)
+  readonly id: string
+
+  @ManyToOne(type => Domain)
+  @Field({ nullable: true })
+  domain?: Domain
+
+  @RelationId((oauth2Client: Oauth2Client) => oauth2Client.domain)
+  domainId?: string
+
+  @Column()
+  @Field()
+  name: string
+
+  @Column({
+    nullable: true
+  })
+  @Field({ nullable: true })
+  description?: string
+
+  @Column({
+    nullable: true
+  })
+  @Field({ nullable: true })
+  icon?: string
+
+  @Column({
+    nullable: true
+  })
+  @Field({ nullable: true })
+  grantType?: string
+
+  @Column({
+    nullable: true
+  })
+  @Field({ nullable: true })
+  clientId?: string
+
+  @Column({
+    nullable: true
+  })
+  @Field({ nullable: true })
+  clientSecret?: string
+
+  @Column({
+    nullable: true
+  })
+  @Field({ nullable: true })
+  accessTokenUrl?: string
+
+  @Column({
+    nullable: true
+  })
+  @Field({ nullable: true })
+  authUrl?: string
+
+  @Column({
+    nullable: true
+  })
+  @Field({ nullable: true })
+  callbackUrl?: string
+
+  @Column({
+    nullable: true
+  })
+  @Field({ nullable: true })
+  webhook?: string
+
+  @Column({
+    nullable: true
+  })
+  @Field({ nullable: true })
+  username?: string
+
+  @Column({
+    nullable: true
+  })
+  @Field({ nullable: true })
+  password?: string
+
+  @Column({
+    nullable: true
+  })
+  @Field({ nullable: true })
+  codeChallengeMethod?: string
+
+  @Column({
+    nullable: true
+  })
+  @Field({ nullable: true })
+  codeVerifier?: string
+
+  @Column({
+    nullable: true
+  })
+  @Field({ nullable: true })
+  scopes?: string
+
+  @Column({
+    nullable: true
+  })
+  @Field({ nullable: true })
+  accessToken?: string
+
+  @Column({
+    nullable: true
+  })
+  @Field({ nullable: true })
+  refreshToken?: string
+
+  @Column()
+  @Field({ nullable: true })
+  expires?: Date
+
+  @Column({
+    nullable: true
+  })
+  @Field({ nullable: true })
+  state?: string
+
+  @Column({
+    nullable: true
+  })
+  @Field({ nullable: true })
+  jwtToken?: string
+
+  @Column({
+    nullable: true
+  })
+  @Field({ nullable: true })
+  tokenType?: string
+
+  @CreateDateColumn()
+  @Field({ nullable: true })
+  createdAt?: Date
+
+  @UpdateDateColumn()
+  @Field({ nullable: true })
+  updatedAt?: Date
+
+  @ManyToOne(type => User, {
+    nullable: true
+  })
+  @Field({ nullable: true })
+  creator?: User
+
+  @RelationId((oauth2Client: Oauth2Client) => oauth2Client.creator)
+  creatorId?: string
+
+  @ManyToOne(type => User, {
+    nullable: true
+  })
+  @Field({ nullable: true })
+  updater?: User
+
+  @RelationId((oauth2Client: Oauth2Client) => oauth2Client.creator)
+  updaterId?: string
+
+  getAuthHeaders() {
+    if (this.tokenType == 'bearer') {
+      return {
+        Authorization: `Bearer ${this.accessToken}`
+      }
+    } else if (this.tokenType == 'basic' || !this.tokenType) {
+      const encoded = Buffer.from(`${this.username}:${this.password}`).toString('base64')
+      return {
+        Authorization: `Basic ${encoded}`
+      }
+    }
+
+    return {}
+  }
+}

package/server/tsconfig.json

@@ -0,0 +1,11 @@
+{
+  "extends": "../../tsconfig-base.json",
+  "compilerOptions": {
+    "strict": false,
+    "declaration": true,
+    "module": "commonjs",
+    "outDir": "../dist-server",
+    "baseUrl": "./"
+  },
+  "include": ["./**/*"]
+}

package/things-factory.config.js

@@ -1,21 +1,12 @@
-import route from './client/route'
-import bootstrap from './client/bootstrap'
+import bootstrap from './dist-client/bootstrap'
+import route from './dist-client/route'
 
 export default {
   route,
   routes: [
-    {
-      tagname: 'oauth2-client-register',
-      page: 'oauth2-client-register'
-    },
-    {
-      tagname: 'oauth2-clients',
-      page: 'oauth2-clients'
-    },
-    {
-      tagname: 'oauth2-client',
-      page: 'oauth2-client'
-    }
+    { tagname: 'oauth2-client-register', page: 'oauth2-client-register' },
+    { tagname: 'oauth2-clients', page: 'oauth2-clients' },
+    { tagname: 'oauth2-client', page: 'oauth2-client' }
   ],
   bootstrap
 }

package/client/index.js

@@ -1 +0,0 @@
-export * from './actions/oauth2-client'