@things-factory/scheduler 8.0.0-beta.9 → 8.0.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@things-factory/scheduler",
-  "version": "8.0.0-beta.9",
+  "version": "8.0.2",
   "main": "dist-server/index.js",
   "browser": "dist-client/index.js",
   "things-factory": true,
@@ -27,11 +27,12 @@
     "migration:create": "node ../../node_modules/typeorm/cli.js migration:create ./server/migrations/migration"
   },
   "dependencies": {
-    "@operato/graphql": "^8.0.0-beta",
-    "@operato/shell": "^8.0.0-beta",
-    "@things-factory/auth-base": "^8.0.0-beta.9",
-    "@things-factory/scheduler-client": "^8.0.0-beta.9",
-    "@things-factory/shell": "^8.0.0-beta.9"
+    "@operato/graphql": "^8.0.0",
+    "@operato/input": "^8.0.0",
+    "@operato/shell": "^8.0.0",
+    "@things-factory/auth-base": "^8.0.2",
+    "@things-factory/scheduler-client": "^8.0.2",
+    "@things-factory/shell": "^8.0.2"
   },
-  "gitHead": "86b1dfa26292926a2d5447fdc23bfa5a9e983245"
+  "gitHead": "39d60f56e142561233ddf6d47b539c637971357c"
 }

package/server/index.ts

@@ -0,0 +1,3 @@
+export * from './service'
+
+import './routes'

package/server/routes.ts

@@ -0,0 +1,28 @@
+const debug = require('debug')('things-factory:scheduler:routes')
+
+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) => {})
+   */
+})
+
+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/index.ts

@@ -0,0 +1,25 @@
+/* EXPORT ENTITY TYPES */
+
+/* IMPORT ENTITIES AND RESOLVERS */
+import {
+  entities as SchedulerEntities,
+  resolvers as SchedulerResolvers,
+  subscribers as SchedulerSubscribers
+} from './schedule'
+
+export const entities = [
+  /* ENTITIES */
+  ...SchedulerEntities
+]
+
+export const subscribers = [
+  /* SUBSCRIBERS */
+  ...SchedulerSubscribers
+]
+
+export const schema = {
+  resolverClasses: [
+    /* RESOLVER CLASSES */
+    ...SchedulerResolvers
+  ]
+}

package/server/service/schedule/index.ts

@@ -0,0 +1,7 @@
+import { Schedule } from './schedule-type'
+import { ScheduleQuery } from './schedule-query'
+import { ScheduleMutation } from './schedule-mutation'
+
+export const entities = [Schedule]
+export const resolvers = [ScheduleQuery, ScheduleMutation]
+export const subscribers = []

package/server/service/schedule/schedule-mutation.ts

@@ -0,0 +1,34 @@
+import { Resolver, Directive, Mutation, Arg, ID } from 'type-graphql'
+
+import { registerSchedule, updateSchedule, unregisterSchedule } from '@things-factory/scheduler-client'
+import { Schedule, NewSchedule, SchedulePatch } from './schedule-type'
+
+@Resolver(Schedule)
+export class ScheduleMutation {
+  @Directive('@privilege(superUserGranted: true)')
+  @Mutation(() => ID)
+  async registerSchedule(@Arg('schedule') schedule: NewSchedule): Promise<string> {
+    var handle = await registerSchedule(schedule)
+
+    return handle
+  }
+
+  @Directive('@privilege(superUserGranted: true)')
+  @Mutation(() => ID)
+  async updateSchedule(@Arg('schedule') schedule: SchedulePatch): Promise<string> {
+    return await updateSchedule(schedule)
+  }
+
+  @Directive('@privilege(superUserGranted: true)')
+  @Mutation(() => Boolean)
+  async unregisterSchedule(@Arg('handle', () => ID) handle: string): Promise<boolean> {
+    try {
+      await unregisterSchedule(handle)
+    } catch (error) {
+      console.error(error)
+      return false
+    }
+
+    return true
+  }
+}

package/server/service/schedule/schedule-query.ts

@@ -0,0 +1,64 @@
+import { Resolver, Query, Args, Arg, Ctx, Directive, ID } from 'type-graphql'
+import { ListParam } from '@things-factory/shell'
+import { User } from '@things-factory/auth-base'
+import { getSchedules, getSchedule } from '@things-factory/scheduler-client'
+import { Schedule, ScheduleList } from './schedule-type'
+
+@Resolver(Schedule)
+export class ScheduleQuery {
+  @Directive('@privilege(superUserGranted: true)')
+  @Query(() => Schedule, { nullable: true })
+  async schedule(@Arg('id', () => ID) id: string): Promise<Schedule | null> {
+    return await getSchedule(id)
+  }
+
+  @Directive('@privilege(superUserGranted: true)')
+  @Query(returns => ScheduleList, { description: 'To fetch multiple Schedules' })
+  async schedules(@Args(type => ListParam) params: ListParam, @Ctx() context: ResolverContext): Promise<ScheduleList> {
+    const filters = params.filters || []
+
+    const name = filters.find(filter => filter.name == 'name')?.value
+
+    const application = filters.find(filter => filter.name == 'application')?.value
+    const group = filters.find(filter => filter.name == 'group')?.value
+    const type = filters.find(filter => filter.name == 'type')?.value
+    const key = filters.find(filter => filter.name == 'key')?.value
+    const operation = filters.find(filter => filter.name == 'operation')?.value
+
+    var schedules = await getSchedules({})
+
+    if (name) {
+      schedules = schedules.filter(schedule => (schedule.name || '').toLowerCase().includes(name.toLowerCase()))
+    }
+    if (application) {
+      schedules = schedules.filter(schedule =>
+        (schedule.client?.application || '').toLowerCase().includes(application.toLowerCase())
+      )
+    }
+    if (group) {
+      schedules = schedules.filter(schedule =>
+        (schedule.client?.group || '').toLowerCase().includes(group.toLowerCase())
+      )
+    }
+    if (type) {
+      schedules = schedules.filter(schedule => (schedule.client?.type || '').toLowerCase().includes(type.toLowerCase()))
+    }
+    if (key) {
+      schedules = schedules.filter(schedule => (schedule.client?.key || '').toLowerCase().includes(key.toLowerCase()))
+    }
+    if (operation) {
+      schedules = schedules.filter(schedule =>
+        (schedule.client?.operation || '').toLowerCase().includes(operation.toLowerCase())
+      )
+    }
+
+    const { page = 1, limit = 20 } = params.pagination || {}
+
+    const start = (page - 1) * limit
+    const end = start + limit
+    const items = schedules.slice(start, end)
+    const total = schedules.length
+
+    return { items, total }
+  }
+}

package/server/service/schedule/schedule-type.ts

@@ -0,0 +1,194 @@
+import { ObjectType, Field, InputType, Int, ID } from 'type-graphql'
+import { ScalarObject } from '@things-factory/shell'
+
+@ObjectType()
+export class ScheduleClient {
+  @Field()
+  application: string
+
+  @Field()
+  group: string
+
+  @Field()
+  type: string
+
+  @Field()
+  key: string
+
+  @Field()
+  operation: string
+}
+
+@ObjectType()
+export class ScheduleTaskConnection {
+  @Field({ nullable: true })
+  host?: string
+
+  @Field(type => ScalarObject, { nullable: true })
+  headers?: Record<string, string>
+
+  @Field({ nullable: true })
+  topic?: string
+}
+
+@ObjectType()
+export class ScheduleTask {
+  @Field()
+  type: string
+
+  @Field(type => ScheduleTaskConnection)
+  connection: ScheduleTaskConnection
+
+  @Field(type => ScalarObject)
+  data: Record<string, any>
+
+  @Field()
+  history_check: boolean
+
+  @Field()
+  failed_policy: 'ignore' | 'retry' | 'retry_dlq'
+
+  @Field(type => Int)
+  retry_wait: number
+
+  @Field(type => Int)
+  retry_count: number
+
+  @Field(type => Int)
+  max_retry_count: number
+}
+
+@ObjectType()
+export class Schedule {
+  @Field(type => ID)
+  id: string
+
+  @Field({ nullable: true })
+  name?: string
+
+  @Field(type => ScheduleClient)
+  client: ScheduleClient
+
+  @Field()
+  type: 'now' | 'delay' | 'date' | 'cron' | 'delay-recur'
+
+  @Field({ nullable: true })
+  schedule?: string
+
+  @Field({ nullable: true })
+  timezone?: string
+
+  @Field(type => ScheduleTask)
+  task: ScheduleTask
+}
+
+@InputType()
+class ScheduleClientInput {
+  @Field()
+  application: string
+
+  @Field()
+  group: string
+
+  @Field()
+  type: string
+
+  @Field()
+  key: string
+
+  @Field()
+  operation: string
+}
+
+@InputType()
+export class ScheduleTaskConnectionInput {
+  @Field({ nullable: true })
+  host?: string
+
+  @Field(type => ScalarObject, { nullable: true })
+  headers?: Record<string, string>
+
+  @Field({ nullable: true })
+  topic?: string
+}
+
+@InputType()
+class ScheduleTaskInput {
+  @Field()
+  type: 'rest' | 'kafka' | 'redis'
+
+  @Field(type => ScheduleTaskConnectionInput)
+  connection: ScheduleTaskConnectionInput
+
+  @Field(type => ScalarObject)
+  data: Record<string, any>
+
+  @Field()
+  history_check: boolean
+
+  @Field()
+  failed_policy: 'ignore' | 'retry' | 'retry_dlq'
+
+  @Field(type => Int)
+  retry_wait: number
+
+  @Field(type => Int)
+  retry_count: number
+
+  @Field(type => Int)
+  max_retry_count: number
+}
+
+@InputType()
+export class NewSchedule {
+  @Field()
+  name: string
+
+  @Field(type => ScheduleClientInput)
+  client: ScheduleClientInput
+
+  @Field()
+  type: 'now' | 'delay' | 'date' | 'cron' | 'delay-recur'
+
+  @Field({ nullable: true })
+  schedule: string
+
+  @Field({ nullable: true })
+  timezone: string
+
+  @Field(type => ScheduleTaskInput)
+  task: ScheduleTaskInput
+}
+
+@InputType()
+export class SchedulePatch {
+  @Field({ nullable: true })
+  id: string
+
+  @Field({ nullable: true })
+  name?: string
+
+  @Field(type => ScheduleClientInput)
+  client: ScheduleClientInput
+
+  @Field()
+  type: 'now' | 'delay' | 'date' | 'cron' | 'delay-recur'
+
+  @Field({ nullable: true })
+  schedule: string
+
+  @Field({ nullable: true })
+  timezone: string
+
+  @Field(type => ScheduleTaskInput)
+  task: ScheduleTaskInput
+}
+
+@ObjectType()
+export class ScheduleList {
+  @Field(type => [Schedule])
+  items: Schedule[]
+
+  @Field(type => Int)
+  total: number
+}

package/server/tsconfig.json

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