protons 7.7.0 → 8.0.1

package/src/fields/enum-field.ts

@@ -0,0 +1,30 @@
+import { Enum } from '../types/enum.ts'
+import { Field } from './field.ts'
+import type { FieldDef } from './field.ts'
+import type { Parent } from '../types/index.ts'
+
+export class EnumField extends Field {
+  private enum: Enum
+
+  constructor (name: string, def: FieldDef, parent: Parent) {
+    super(name, def, parent)
+
+    const type = parent.findType(def.type)
+
+    if (!(type instanceof Enum)) {
+      throw new Error(`Type "${def.type}" was not an Enum`)
+    }
+
+    this.enum = type
+  }
+
+  getDefaultField (parent: Parent): string {
+    if (this.optional) {
+      return ''
+    }
+
+    const type = parent.findType(this.type)
+
+    return `${this.name}: ${type.pbType}.${this.enum.lowestValueName}`
+  }
+}

package/src/fields/field.ts

@@ -0,0 +1,201 @@
+import { ParseError } from 'protons-runtime'
+import { Enum } from '../types/enum.ts'
+import { Message } from '../types/message.ts'
+import type { Parent, Type } from '../types/index.ts'
+
+export const CODEC_TYPES = {
+  VARINT: 0,
+  BIT64: 1,
+  LENGTH_DELIMITED: 2,
+  START_GROUP: 3,
+  END_GROUP: 4,
+  BIT32: 5
+}
+
+export const codecTypes: Record<string, number> = {
+  bool: CODEC_TYPES.VARINT,
+  bytes: CODEC_TYPES.LENGTH_DELIMITED,
+  double: CODEC_TYPES.BIT64,
+  enum: CODEC_TYPES.VARINT,
+  fixed32: CODEC_TYPES.BIT32,
+  fixed64: CODEC_TYPES.BIT64,
+  float: CODEC_TYPES.BIT32,
+  int32: CODEC_TYPES.VARINT,
+  int64: CODEC_TYPES.VARINT,
+  message: CODEC_TYPES.LENGTH_DELIMITED,
+  sfixed32: CODEC_TYPES.BIT32,
+  sfixed64: CODEC_TYPES.BIT64,
+  sint32: CODEC_TYPES.VARINT,
+  sint64: CODEC_TYPES.VARINT,
+  string: CODEC_TYPES.LENGTH_DELIMITED,
+  uint32: CODEC_TYPES.VARINT,
+  uint64: CODEC_TYPES.VARINT
+}
+
+const jsTypeOverrides: Record<string, 'number' | 'string'> = {
+  JS_NUMBER: 'number',
+  JS_STRING: 'string'
+}
+
+interface DefaultValueGenerator {
+  (): string
+}
+
+const defaultValueGenerators: Record<string, DefaultValueGenerator> = {
+  bool: () => 'false',
+  bytes: () => 'uint8ArrayAlloc(0)',
+  double: () => '0',
+  fixed32: () => '0',
+  fixed64: () => '0n',
+  float: () => '0',
+  int32: () => '0',
+  int64: () => '0n',
+  sfixed32: () => '0',
+  sfixed64: () => '0n',
+  sint32: () => '0',
+  sint64: () => '0n',
+  string: () => "''",
+  uint32: () => '0',
+  uint64: () => '0n'
+}
+
+const defaultValueGeneratorsJsTypeOverrides: Record<string, DefaultValueGenerator> = {
+  number: () => '0',
+  string: () => "''"
+}
+
+export interface FieldOptions extends Record<string, any> {
+  proto3_optional?: boolean
+  jstype?: 'string' | 'number'
+}
+
+export interface FieldDef {
+  id: number
+  type: string
+  repeated?: boolean
+  options?: FieldOptions
+  rule?: string
+  oneof?: string[]
+}
+
+export interface MessageField {
+  /**
+   * Return a string that can be used in a typescript interface for this field
+   */
+  getInterfaceField (parent: Parent, indent?: string): string
+}
+
+export class Field implements MessageField {
+  public id: number
+  public name: string
+  public optional: boolean
+  public type: string
+  public proto2Required: boolean
+  public jsTypeOverride?: 'string' | 'number'
+  public oneof?: string[]
+
+  constructor (name: string, def: FieldDef, parent: Parent) {
+    this.id = def.id
+    this.name = name
+
+    // the default type for a message is unset so they are always optional
+    // https://developers.google.com/protocol-buffers/docs/proto3#default
+    this.optional = def.repeated !== true && def.options?.proto3_optional === true
+    this.type = def.type ?? 'string'
+    this.oneof = def.oneof
+    this.proto2Required = false
+
+    if (def.options?.jstype != null) {
+      this.jsTypeOverride = jsTypeOverrides[def.options.jstype]
+    }
+
+    if (this.jsTypeOverride != null && !['int64', 'uint64', 'sint64', 'fixed64', 'sfixed64'].includes(this.type)) {
+      throw new Error(`jstype override option is only allowed on int64, uint64, sint64, fixed64 or sfixed64 fields - got "${this.type}"`)
+    }
+
+    if (def.rule === 'required') {
+      const message = `field "${name}" is required, this is not allowed in proto3. Please convert your proto2 definitions to proto3 - see https://github.com/ipfs/protons/wiki/Required-fields-and-protobuf-3`
+
+      if (parent.flags?.strict === true) {
+        throw new ParseError(message)
+      } else {
+        this.proto2Required = true
+
+        // eslint-disable-next-line no-console
+        console.info(`[WARN] ${message}`)
+      }
+    }
+  }
+
+  getInterfaceField (parent: Parent, indent = ''): string {
+    return `${indent}${this.name}${this.optional ? '?' : ''}: ${this.jsTypeOverride ?? parent.findType(this.type).jsType}`
+  }
+
+  getDefaultField (parent: Parent): string {
+    if (this.optional) {
+      return ''
+    }
+
+    const type = parent.findType(this.type)
+
+    if (type.pbType === 'bytes') {
+      parent.addImport('uint8arrays/alloc', 'alloc', 'uint8ArrayAlloc')
+    }
+
+    let defaultValueGenerator = defaultValueGenerators[type.pbType]
+
+    if (this.jsTypeOverride) {
+      defaultValueGenerator = defaultValueGeneratorsJsTypeOverrides[this.jsTypeOverride]
+    }
+
+    if (defaultValueGenerator == null) {
+      return ''
+    }
+
+    return `${this.name}: ${defaultValueGenerator()}`
+  }
+
+  getDecoder (parent: Parent): string {
+    const type: Type = parent.findType(this.type)
+
+    return `case ${this.id}: {
+              obj.${this.name} = ${type.getDecoder(this)}
+              break
+            }`
+  }
+
+  getStreamingDecoder (parent: Parent): string {
+    const type: Type = parent.findType(this.type)
+
+    return `case ${this.id}: {
+              yield {
+                field: \`\${prefix != null ? \`\${prefix}\` : '$'}.${this.name}\`,
+                value: ${type.getDecoder(this, '  ')}
+              }
+              break
+            }`
+  }
+
+  getEncoder (parent: Parent): string {
+    const type = parent.findType(this.type)
+    let id = (this.id << 3) | codecTypes[this.type]
+
+    if (type instanceof Message) {
+      id = (this.id << 3) | codecTypes.message
+    }
+
+    if (type instanceof Enum) {
+      id = (this.id << 3) | codecTypes.enum
+    }
+
+    return `
+        if (${type.getValueTest(this, `obj.${this.name}`)}) {
+          w.uint32(${id})
+          ${type.getEncoder(this, `obj.${this.name}`)}
+        }`
+  }
+
+  getLimitField (): string {
+    return ''
+  }
+}

package/src/fields/map-field.ts

@@ -0,0 +1,107 @@
+import { codecTypes, Field } from './field.ts'
+import type { FieldDef } from './field.ts'
+import type { Parent } from '../types/index.ts'
+
+export interface MapFieldDef extends FieldDef {
+  keyType?: string
+  valueType: string
+}
+
+export function isMapFieldDef (obj?: any): obj is MapFieldDef {
+  return obj?.keyType != null
+}
+
+export class MapField extends Field {
+  public keyType: string
+  public valueType: string
+  public entryType: string
+  private lengthLimit?: number
+
+  constructor (name: string, def: MapFieldDef, parent: Parent) {
+    super(name, def, parent)
+
+    this.type = 'message'
+    this.keyType = def.keyType ?? 'string'
+    this.valueType = def.valueType
+    this.entryType = def.type
+    this.lengthLimit = def.options?.['(protons.options).limit']
+  }
+
+  getInterfaceField (parent: Parent): string {
+    return `${this.name}: Map<${parent.findType(this.keyType).jsType}, ${parent.findType(this.valueType).jsType}>`
+  }
+
+  getDefaultField (parent: Parent): string {
+    return `${this.name}: new Map<${parent.findType(this.keyType).jsType}, ${parent.findType(this.valueType).jsType}>()`
+  }
+
+  getEncoder (parent: Parent): string {
+    const id = (this.id << 3) | codecTypes.message
+    const entryType = parent.findType(this.entryType)
+
+    return `
+        if (${entryType.getValueTest(this, 'value')}) {
+          for (const [key, value] of obj.${this.name}.entries()) {
+            w.uint32(${id})
+            ${entryType.getEncoder(this, '{ key, value }')}
+          }
+        }`
+  }
+
+  getDecoder (parent: Parent): string {
+    parent.addImport('protons-runtime', 'MaxSizeError')
+    const entryType = parent.findType(this.entryType)
+
+    let limit = `
+              if (opts.limits?.${this.name} != null && obj.${this.name}.size === opts.limits.${this.name}) {
+                throw new MaxSizeError('Decode error - map field "${this.name}" had too many elements')
+              }
+`
+
+    if (this.lengthLimit != null) {
+      limit += `
+              if (obj.${this.name}.size === ${this.lengthLimit}) {
+                throw new MaxSizeError('Decode error - map field "${this.name}" had too many elements')
+              }
+`
+    }
+
+    return `case ${this.id}: {${limit}
+              const entry = ${entryType.getDecoder(this)}
+              obj.${this.name}.set(entry.key, entry.value)
+              break
+            }`
+  }
+
+  getStreamingDecoder (parent: Parent): string {
+    parent.addImport('protons-runtime', 'MaxLengthError')
+
+    let limit = `
+              if (opts.limits?.${this.name} != null && obj.${this.name} === opts.limits.${this.name}) {
+                throw new MaxLengthError('Decode error - map field "${this.name}" had too many elements')
+              }
+`
+
+    if (this.lengthLimit != null) {
+      limit += `
+              if (obj.${this.name} === ${this.lengthLimit}) {
+                throw new MaxLengthError('Decode error - repeated field "${this.name}" had too many elements')
+              }
+`
+    }
+
+    const type = parent.findType(this.entryType)
+
+    return `case ${this.id}: {${limit}
+              ${type.getStreamingDecoder(this, `\`\${prefix != null ? \`\${prefix}\` : '$'}.${this.name}{}\``, '  ')}
+
+              obj.${this.name}++
+
+              break
+            }`
+  }
+
+  getLimitField (): string {
+    return `${this.name}: ${this.lengthLimit ?? 0}`
+  }
+}

package/src/fields/message-field.ts

@@ -0,0 +1,29 @@
+import { Message } from '../types/message.ts'
+import { Field } from './field.ts'
+import type { Parent, Type } from '../types/index.ts'
+
+export class MessageField extends Field {
+  getInterfaceField (parent: Parent, indent = ''): string {
+    return `${indent}${this.name}?: ${parent.findType(this.type).jsType}`
+  }
+
+  getMessage (parent: Parent): Message {
+    const type = parent.findType(this.type)
+
+    if (!(type instanceof Message)) {
+      throw new Error(`Field ${this.name} was not a message field`)
+    }
+
+    return type
+  }
+
+  getStreamingDecoder (parent: Parent): string {
+    const type: Type = parent.findType(this.type)
+
+    return `case ${this.id}: {
+              ${type.getStreamingDecoder(this, `\`\${prefix != null ? \`\${prefix}\` : '$'}.${this.name}\``, '  ')}
+
+              break
+            }`
+  }
+}