@sentio/sdk 2.39.3 → 2.39.4-rc.10

package/src/store/codegen.ts

@@ -1,7 +1,5 @@
 import {
-  DirectiveNode,
   GraphQLEnumType,
-  GraphQLField,
   GraphQLInterfaceType,
   GraphQLList,
   GraphQLNonNull,
@@ -9,10 +7,9 @@ import {
   GraphQLOutputType,
   GraphQLScalarType,
   GraphQLSchema,
-  Kind,
-  isObjectType,
-  isInterfaceType,
-  isListType
+  isEnumType,
+  isListType,
+  isNonNullType
 } from 'graphql'
 import * as fs from 'node:fs'
 import path from 'path'
@@ -20,6 +17,35 @@ import mkdirp from 'mkdirp'
 import { schemaFromFile } from './schema.js'
 import chalk from 'chalk'
 
+interface Import {
+  module: string
+  types: string[]
+  importType?: boolean
+}
+
+interface Field {
+  name: string
+  type: string
+  annotations: string[]
+}
+
+interface Class {
+  name: string
+  fields: Field[]
+  annotations: string[]
+  interfaces: string[]
+}
+
+interface Interface {
+  name: string
+  fields: Field[]
+}
+
+interface Enum {
+  name: string
+  values: string[]
+}
+
 export async function codegen(srcDir: string, outputDir: string) {
   for (const file of fs.readdirSync(srcDir)) {
     const f = path.join(srcDir, file)
@@ -33,41 +59,164 @@ export async function codegen(srcDir: string, outputDir: string) {
   }
 }
 
+function addTypeAnnotations(ty: GraphQLOutputType, annotations: string[]) {
+  if (isNonNullType(ty)) {
+    annotations.push('@Required')
+    addTypeAnnotations(ty.ofType, annotations)
+    return
+  }
+
+  if (isRelationType(ty)) {
+    if (isListType(ty)) {
+      annotations.push(`@Many("${ty.ofType}")`)
+    } else {
+      annotations.push(`@One("${ty}")`)
+    }
+  } else if (isEnumType(ty)) {
+    annotations.push(`@Column("String${isNonNullType(ty) ? '!' : ''}")`)
+  } else {
+    if (isListType(ty)) {
+      if (isListType(ty.ofType)) {
+        annotations.push(`@ListColumn()`)
+        addTypeAnnotations(ty.ofType, annotations)
+      } else {
+        annotations.push(`@ListColumn("${ty.ofType}")`)
+      }
+    } else {
+      annotations.push(`@Column("${ty}")`)
+    }
+  }
+}
+
 async function codegenInternal(schema: GraphQLSchema, source: string, target: string) {
-  const results: string[] = [
-    '/* Autogenerated file. Do not edit manually. */\n',
-    '/* tslint:disable */',
-    '/* eslint-disable */',
-    "import {entity, derivedFrom, DateTime, Int, Float, String, Json, Bytes, ID, Entity, Store} from '@sentio/sdk/store'",
-    `import { DatabaseSchema, BigDecimal } from "@sentio/sdk"`
+  const imports: Import[] = [
+    {
+      module: '@sentio/sdk/store',
+      types: ['String', 'Int', 'BigInt', 'Float', 'ID', 'Bytes', 'Timestamp', 'Boolean'],
+      importType: true
+    },
+    {
+      module: '@sentio/sdk/store',
+      types: ['Entity', 'Required', 'One', 'Many', 'Column', 'ListColumn']
+    },
+    {
+      module: '@sentio/bigdecimal',
+      types: ['BigDecimal']
+    },
+    {
+      module: '@sentio/sdk',
+      types: ['DatabaseSchema']
+    }
   ]
-  const entities: string[] = []
+  const enumns: Enum[] = []
+  const interfaces: Interface[] = []
+  const classes: Class[] = []
+
   for (const t of Object.values(schema.getTypeMap())) {
     if (t.name.startsWith('__')) {
       continue
     }
-
-    if (t instanceof GraphQLObjectType) {
-      const entityContent = genEntity(t)
-      results.push(entityContent)
-      entities.push(t.name)
-    }
     if (t instanceof GraphQLEnumType) {
-      results.push(genEnum(t))
+      enumns.push({
+        name: t.name,
+        values: t.getValues().map((v) => v.value)
+      })
     }
     if (t instanceof GraphQLInterfaceType) {
-      results.push(genInterface(t))
+      interfaces.push({
+        name: t.name,
+        fields: Object.values(t.getFields()).map((f) => ({
+          name: f.name,
+          type: genType(f.type),
+          annotations: []
+        }))
+      })
+    }
+  }
+  for (const t of Object.values(schema.getTypeMap())) {
+    if (t.name.startsWith('__')) {
+      continue
+    }
+
+    if (t instanceof GraphQLObjectType) {
+      const fields: Field[] = []
+      for (const f of Object.values(t.getFields())) {
+        const type = genType(f.type)
+        const annotations: string[] = []
+        addTypeAnnotations(f.type, annotations)
+        if (isRelationType(f.type)) {
+          fields.push({
+            name: f.name,
+            type: `Promise<${type}>`,
+            annotations
+          })
+          const isMany = type.startsWith('Array')
+          fields.push({
+            name: f.name + 'ID' + (isMany ? 's' : ''),
+            type: isMany ? `Array<ID | undefined>` : `ID`,
+            annotations: []
+          })
+        } else {
+          fields.push({
+            name: f.name,
+            type: type,
+            annotations
+          })
+        }
+      }
+      classes.push({
+        name: t.name,
+        fields,
+        annotations: [`@Entity("${t.name}")`],
+        interfaces: t.getInterfaces().map((i) => i.name)
+      })
     }
   }
 
+  const template = `
+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+${imports.map((i) => `import ${i.importType ? 'type ' : ''}{ ${i.types.join(', ')} } from '${i.module}'`).join('\n')}
+
+${enumns
+  .map(
+    (e) => `export enum ${e.name} {
+  ${e.values.map((v) => `${v} = "${v}"`).join(', ')}
+}`
+  )
+  .join('\n')}
+
+${interfaces
+  .map(
+    (i) => `export interface ${i.name} {
+  ${i.fields.map((f) => `\t${f.name}: ${f.type}`).join('\n')}
+}`
+  )
+  .join('\n')}
+
+${classes
+  .map(
+    (c) => `
+${c.annotations.join('\n')}
+export class ${c.name} ${c.interfaces.length > 0 ? `implements ${c.interfaces.join(', ')}` : ''} {
+${c.fields.map((f) => `${f.annotations.map((a) => `\n\t${a}`).join('')}\n\t${f.name}: ${f.type}`).join('\n')}
+
+  constructor(data: Partial<${c.name}>) {}
+
+}`
+  )
+  .join('\n')}
+`
+
   const contents =
-    results.join('\n') +
+    template +
     `\n
 const source = \`${source.replaceAll('`', '`')}\`
 DatabaseSchema.register({
   source,
   entities: {
-    ${entities.map((e) => `"${e}": ${e}`).join(',\n\t\t')}
+    ${classes.map((e) => `"${e.name}": ${e.name}`).join(',\n\t\t')}
   }
 })
 `
@@ -76,181 +225,30 @@ DatabaseSchema.register({
   fs.writeFileSync(target, contents)
 }
 
-const JsTypes: Record<string, string> = {
-  ID: 'string',
-  String: 'string',
-  Int: 'number',
-  Float: 'number',
-  Boolean: 'boolean',
-  BigInt: 'bigint',
-  BigDecimal: 'BigDecimal',
-  DateTime: 'Date',
-  Json: 'any',
-  Bytes: 'Uint8Array'
-}
-const graphqlTypes = Object.entries(JsTypes).reduce(
-  (acc, [k, v]) => {
-    acc[v] = k
-    return acc
-  },
-  {} as Record<string, string>
-)
-
-function genType(type: GraphQLOutputType): string {
+function genType(type: GraphQLOutputType, required?: boolean): string {
   if (type instanceof GraphQLNonNull) {
-    return genType(type.ofType)
+    return genType(type.ofType, true)
   } else if (type instanceof GraphQLScalarType) {
-    return type.name
+    return required ? type.name : `${type.name} | undefined`
   } else if (type instanceof GraphQLObjectType || type instanceof GraphQLInterfaceType) {
-    return type.name
+    return required ? type.name : `${type.name} | undefined`
   } else if (type instanceof GraphQLList) {
     return `Array<${genType(type.ofType)}>`
   } else if (type instanceof GraphQLEnumType) {
-    return type.name
+    return required ? type.name : `${type.name} | undefined`
   } else {
     throw new Error('Unsupported type: ' + type)
   }
 }
 
-function isObject(type: GraphQLOutputType) {
-  if (type instanceof GraphQLNonNull) {
-    return isObject(type.ofType)
-  } else if (type instanceof GraphQLList) {
-    return isObject(type.ofType)
-  }
-  return isObjectType(type) || isInterfaceType(type)
-}
-
-function isList(type: GraphQLOutputType) {
+function isRelationType(type: GraphQLOutputType): boolean {
   if (type instanceof GraphQLNonNull) {
-    return isListType(type.ofType)
-  } else {
-    return isListType(type)
-  }
-}
-
-function getElementType(type: GraphQLOutputType) {
-  if (type instanceof GraphQLNonNull) {
-    return getElementType(type.ofType)
+    return isRelationType(type.ofType)
+  } else if (type instanceof GraphQLObjectType || type instanceof GraphQLInterfaceType) {
+    return true
   } else if (type instanceof GraphQLList) {
-    return type.ofType
-  }
-  return type
-}
-
-function genField(field: GraphQLField<any, any>) {
-  const isNonNull = field.type instanceof GraphQLNonNull
-  const directives = field.astNode?.directives?.map((d) => '\t' + directive2decorator(d) + '\n') || []
-
-  const type = genType(field.type)
-  const returnType = isNonNull ? type : `${type} | undefined`
-
-  if (isObject(field.type)) {
-    const t = getElementType(field.type)
-    const typeAsArg = isInterfaceType(t) ? `"${t}"` : genType(t)
-
-    if (isList(field.type)) {
-      return `${directives.join()}\tget ${field.name}(): Promise<${genType(t)}[]> { return this.getFieldObjectArray(${typeAsArg}, "${field.name}") as Promise<${genType(t)}[]> }
-  set ${field.name}(value: ${type} | ID[]) { this.set("${field.name}", value) }
-  get ${field.name}Ids(): ID[] { return this.get("${field.name}") }`
-    }
-
-    return `${directives.join()}\tget ${field.name}(): Promise<${genType(t)} | undefined> { return this.getFieldObject(${typeAsArg},"${field.name}") as Promise<${genType(t)} | undefined> }
-  set ${field.name}(value: ${type} | ID) { this.set("${field.name}", value) }
-  get ${field.name}Id(): ID | undefined { return this.get("${field.name}") }`
-  }
-
-  if (returnType == 'BigInt') {
-    return `${directives.join()}\tget ${field.name}(): bigint { return BigInt(this.get("${field.name}")) }
-  set ${field.name}(value: ${type}) { this.set("${field.name}", value.toString()) }`
-  }
-  if (returnType == 'BigDecimal') {
-    return `${directives.join()}\tget ${field.name}(): ${returnType} { return new BigDecimal(this.get("${field.name}")) }
-  set ${field.name}(value: ${type}) { this.set("${field.name}", value.toString()) }`
-  }
-
-  if (returnType == 'Bytes') {
-    return `${directives.join()}\tget ${field.name}(): ${returnType} { return Uint8Array.from(Buffer.from(this.get<string>("${field.name}"), 'hex'))  ) }
-  set ${field.name}(value: ${type}) { this.set("${field.name}", Buffer.from(value).toString('hex')) }`
-  }
-
-  return `${directives.join()}\tget ${field.name}(): ${returnType} { return this.get("${field.name}") }
-  set ${field.name}(value: ${type}) { this.set("${field.name}", value) }`
-}
-
-function genDataType(t: GraphQLObjectType<any, any>) {
-  let output = `type ${t.name}Data = `
-  const relationsFields = Object.values(t.getFields()).filter((f) => isObject(f.type))
-  if (relationsFields.length > 0) {
-    output += `Omit<${t.name}, ${relationsFields.map((f) => `"${f.name}"`).join(' | ')}>`
-
-    output +=
-      ' & {' +
-      relationsFields
-        .map((f) => {
-          const type = genType(getElementType(f.type))
-          return `${f.name}?: ${isList(f.type) ? `Array<ID|${type}>` : `ID | ${type}`}`
-        })
-        .join(', ') +
-      '}'
+    return isRelationType(type.ofType)
   } else {
-    output += `${t.name}`
-  }
-  return output
-}
-
-function genEntity(t: GraphQLObjectType<any, any>) {
-  const decorators = t.astNode?.directives?.filter((d) => d.name.value != 'entity').map(directive2decorator) || []
-
-  let impls = ''
-  if (t.getInterfaces().length > 0) {
-    impls +=
-      ' implements ' +
-      t
-        .getInterfaces()
-        .map((i) => i.name)
-        .join(', ')
-  }
-
-  return `
-${genDataType(t)}
-${decorators.join('\n')}
-@entity("${t.name}")
-export class ${t.name} extends Entity${impls} {
-  constructor(data: Partial<${t.name}Data>) {
-    super(data)
+    return false
   }
-${Object.values(t.getFields()).map(genField).join('\n')}
-}`
-}
-
-function genInterface(t: GraphQLInterfaceType) {
-  return `
-export interface ${t.name} {
-${Object.values(t.getFields())
-  .map((f) => `\t${f.name}: ${genType(f.type)}`)
-  .join('\n')}
-}`
-}
-
-export function directive2decorator(directive: DirectiveNode) {
-  let s = `@${directive.name.value}`
-  if (directive.arguments?.length) {
-    s += `(${directive.arguments
-      ?.map((arg) => {
-        return arg.value.kind === Kind.STRING ? `"${arg.value.value}"` : `${arg.value}`
-      })
-      .join(', ')})`
-  }
-  return s
-}
-
-function genEnum(t: GraphQLEnumType) {
-  return `
-export enum ${t.name} {
-${t
-  .getValues()
-  .map((v) => `\t${v.name}`)
-  .join(', ')}
-}`
 }