fix: remove redundant defs and declare codec return type (#28)

When generating code, if a namespace doesn't have any fields, don't declare an interface for it as it fails some linting checks.

Also, declare the return type of generated codec methods as we know it and it's a linting issue for some setups.

packages/protons-runtime/src/codecs/codec.ts → packages/protons-runtime/src/codec.ts

@@ -24,13 +24,13 @@ export interface EncodingLengthFunction<T> {
 
 export interface Codec<T> {
   name: string
-  type: number
+  type: CODEC_TYPES
   encode: EncodeFunction<T>
   decode: DecodeFunction<T>
   encodingLength: EncodingLengthFunction<T>
 }
 
-export function createCodec <T> (name: string, type: number, encode: EncodeFunction<T>, decode: DecodeFunction<T>, encodingLength: EncodingLengthFunction<T>): Codec<T> {
+export function createCodec <T> (name: string, type: CODEC_TYPES, encode: EncodeFunction<T>, decode: DecodeFunction<T>, encodingLength: EncodingLengthFunction<T>): Codec<T> {
   return {
     name,
     type,

packages/protons-runtime/src/codecs/bool.ts

@@ -1,4 +1,5 @@
-import { DecodeFunction, EncodeFunction, createCodec, EncodingLengthFunction, CODEC_TYPES } from './codec.js'
+import { createCodec, CODEC_TYPES } from '../codec.js'
+import type { DecodeFunction, EncodeFunction, EncodingLengthFunction } from '../codec.js'
 
 const encodingLength: EncodingLengthFunction<boolean> = function boolEncodingLength () {
   return 1

packages/protons-runtime/src/codecs/bytes.ts

@@ -1,7 +1,8 @@
 
 import { Uint8ArrayList } from 'uint8arraylist'
 import { unsigned } from '../utils/varint.js'
-import { DecodeFunction, EncodeFunction, createCodec, EncodingLengthFunction, CODEC_TYPES } from './codec.js'
+import { createCodec, CODEC_TYPES } from '../codec.js'
+import type { DecodeFunction, EncodeFunction, EncodingLengthFunction } from '../codec.js'
 
 const encodingLength: EncodingLengthFunction<Uint8Array> = function bytesEncodingLength (val) {
   const len = val.byteLength

packages/protons-runtime/src/codecs/double.ts

@@ -1,5 +1,6 @@
 import { Uint8ArrayList } from 'uint8arraylist'
-import { DecodeFunction, EncodeFunction, createCodec, EncodingLengthFunction, CODEC_TYPES } from './codec.js'
+import { createCodec, CODEC_TYPES } from '../codec.js'
+import type { DecodeFunction, EncodeFunction, EncodingLengthFunction } from '../codec.js'
 
 const encodingLength: EncodingLengthFunction<number> = function doubleEncodingLength () {
   return 8

packages/protons-runtime/src/codecs/enum.ts

@@ -1,6 +1,7 @@
 
 import { unsigned } from '../utils/varint.js'
-import { DecodeFunction, EncodeFunction, createCodec, EncodingLengthFunction, Codec, CODEC_TYPES } from './codec.js'
+import { createCodec, CODEC_TYPES } from '../codec.js'
+import type { DecodeFunction, EncodeFunction, EncodingLengthFunction, Codec } from '../codec.js'
 
 export function enumeration <T> (e: T): Codec<T> {
   const encodingLength: EncodingLengthFunction<string> = function enumEncodingLength (val: string) {

packages/protons-runtime/src/codecs/fixed32.ts

@@ -1,5 +1,6 @@
 import { Uint8ArrayList } from 'uint8arraylist'
-import { DecodeFunction, EncodeFunction, createCodec, EncodingLengthFunction, CODEC_TYPES } from './codec.js'
+import { createCodec, CODEC_TYPES } from '../codec.js'
+import type { DecodeFunction, EncodeFunction, EncodingLengthFunction } from '../codec.js'
 
 const encodingLength: EncodingLengthFunction<number> = function fixed32EncodingLength () {
   return 4

packages/protons-runtime/src/codecs/fixed64.ts

@@ -1,5 +1,6 @@
 import { Uint8ArrayList } from 'uint8arraylist'
-import { DecodeFunction, EncodeFunction, createCodec, EncodingLengthFunction, CODEC_TYPES } from './codec.js'
+import { createCodec, CODEC_TYPES } from '../codec.js'
+import type { DecodeFunction, EncodeFunction, EncodingLengthFunction } from '../codec.js'
 
 const encodingLength: EncodingLengthFunction<bigint> = function int64EncodingLength (val) {
   return 8

packages/protons-runtime/src/codecs/float.ts

@@ -1,5 +1,6 @@
 import { Uint8ArrayList } from 'uint8arraylist'
-import { DecodeFunction, EncodeFunction, createCodec, EncodingLengthFunction, CODEC_TYPES } from './codec.js'
+import { createCodec, CODEC_TYPES } from '../codec.js'
+import type { DecodeFunction, EncodeFunction, EncodingLengthFunction } from '../codec.js'
 
 const encodingLength: EncodingLengthFunction<number> = function floatEncodingLength () {
   return 4

packages/protons-runtime/src/codecs/int32.ts

@@ -1,5 +1,6 @@
 import { signed } from '../utils/varint.js'
-import { DecodeFunction, EncodeFunction, createCodec, EncodingLengthFunction, CODEC_TYPES } from './codec.js'
+import { createCodec, CODEC_TYPES } from '../codec.js'
+import type { DecodeFunction, EncodeFunction, EncodingLengthFunction } from '../codec.js'
 
 const encodingLength: EncodingLengthFunction<number> = function int32EncodingLength (val) {
   return signed.encodingLength(val)

packages/protons-runtime/src/codecs/int64.ts

@@ -1,5 +1,6 @@
 import { signed } from '../utils/big-varint.js'
-import { DecodeFunction, EncodeFunction, createCodec, EncodingLengthFunction, CODEC_TYPES } from './codec.js'
+import { createCodec, CODEC_TYPES } from '../codec.js'
+import type { DecodeFunction, EncodeFunction, EncodingLengthFunction } from '../codec.js'
 
 const encodingLength: EncodingLengthFunction<bigint> = function int64EncodingLength (val) {
   return signed.encodingLength(val)

packages/protons-runtime/src/codecs/message.ts

@@ -1,7 +1,8 @@
 import { unsigned } from '../utils/varint.js'
-import type { FieldDef, FieldDefs } from '../index.js'
-import { DecodeFunction, EncodeFunction, createCodec, EncodingLengthFunction, Codec, CODEC_TYPES } from './codec.js'
+import { createCodec, CODEC_TYPES } from '../codec.js'
+import type { DecodeFunction, EncodeFunction, EncodingLengthFunction, Codec } from '../codec.js'
 import { Uint8ArrayList } from 'uint8arraylist'
+import type { FieldDefs, FieldDef } from '../index.js'
 
 export interface Factory<A, T> {
   new (obj: A): T

packages/protons-runtime/src/codecs/sfixed32.ts

@@ -1,5 +1,6 @@
 import { Uint8ArrayList } from 'uint8arraylist'
-import { DecodeFunction, EncodeFunction, createCodec, EncodingLengthFunction, CODEC_TYPES } from './codec.js'
+import { createCodec, CODEC_TYPES } from '../codec.js'
+import type { DecodeFunction, EncodeFunction, EncodingLengthFunction } from '../codec.js'
 
 const encodingLength: EncodingLengthFunction<number> = function sfixed32EncodingLength () {
   return 4

packages/protons-runtime/src/codecs/sfixed64.ts

@@ -1,5 +1,6 @@
 import { Uint8ArrayList } from 'uint8arraylist'
-import { DecodeFunction, EncodeFunction, createCodec, EncodingLengthFunction, CODEC_TYPES } from './codec.js'
+import { createCodec, CODEC_TYPES } from '../codec.js'
+import type { DecodeFunction, EncodeFunction, EncodingLengthFunction } from '../codec.js'
 
 const encodingLength: EncodingLengthFunction<bigint> = function sfixed64EncodingLength () {
   return 8

packages/protons-runtime/src/codecs/sint32.ts

@@ -1,5 +1,6 @@
 import { zigzag } from '../utils/varint.js'
-import { DecodeFunction, EncodeFunction, createCodec, EncodingLengthFunction, CODEC_TYPES } from './codec.js'
+import { createCodec, CODEC_TYPES } from '../codec.js'
+import type { DecodeFunction, EncodeFunction, EncodingLengthFunction } from '../codec.js'
 
 const encodingLength: EncodingLengthFunction<number> = function sint32EncodingLength (val) {
   return zigzag.encodingLength(val)

packages/protons-runtime/src/codecs/sint64.ts

@@ -1,5 +1,6 @@
 import { zigzag } from '../utils/big-varint.js'
-import { DecodeFunction, EncodeFunction, createCodec, EncodingLengthFunction, CODEC_TYPES } from './codec.js'
+import { createCodec, CODEC_TYPES } from '../codec.js'
+import type { DecodeFunction, EncodeFunction, EncodingLengthFunction } from '../codec.js'
 
 const encodingLength: EncodingLengthFunction<bigint> = function int64EncodingLength (val) {
   return zigzag.encodingLength(val)

packages/protons-runtime/src/codecs/string.ts

@@ -1,7 +1,8 @@
 import { unsigned } from '../utils/varint.js'
 import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
 import { toString as uint8ArrayToString } from 'uint8arrays/to-string'
-import { DecodeFunction, EncodeFunction, createCodec, EncodingLengthFunction, CODEC_TYPES } from './codec.js'
+import { createCodec, CODEC_TYPES } from '../codec.js'
+import type { DecodeFunction, EncodeFunction, EncodingLengthFunction } from '../codec.js'
 import { Uint8ArrayList } from 'uint8arraylist'
 
 const encodingLength: EncodingLengthFunction<string> = function stringEncodingLength (val) {

packages/protons-runtime/src/codecs/uint32.ts

@@ -1,5 +1,6 @@
 import { unsigned } from '../utils/varint.js'
-import { DecodeFunction, EncodeFunction, createCodec, EncodingLengthFunction, CODEC_TYPES } from './codec.js'
+import { createCodec, CODEC_TYPES } from '../codec.js'
+import type { DecodeFunction, EncodeFunction, EncodingLengthFunction } from '../codec.js'
 
 const encodingLength: EncodingLengthFunction<number> = function uint32EncodingLength (val) {
   return unsigned.encodingLength(val)

packages/protons-runtime/src/codecs/uint64.ts

@@ -1,5 +1,6 @@
 import { unsigned } from '../utils/big-varint.js'
-import { DecodeFunction, EncodeFunction, createCodec, EncodingLengthFunction, CODEC_TYPES } from './codec.js'
+import { createCodec, CODEC_TYPES } from '../codec.js'
+import type { DecodeFunction, EncodeFunction, EncodingLengthFunction } from '../codec.js'
 
 const encodingLength: EncodingLengthFunction<bigint> = function uint64EncodingLength (val) {
   return unsigned.encodingLength(val)

packages/protons-runtime/src/decode.ts

@@ -1,6 +1,6 @@
 import { Uint8ArrayList } from 'uint8arraylist'
 import { unsigned } from './utils/varint.js'
-import type { Codec } from './codecs/codec.js'
+import type { Codec } from './codec.js'
 
 export function decodeMessage <T> (buf: Uint8Array, codec: Codec<T>) {
   // wrap root message

packages/protons-runtime/src/encode.ts

@@ -1,4 +1,4 @@
-import type { Codec } from './codecs/codec.js'
+import type { Codec } from './codec.js'
 import { unsigned } from './utils/varint.js'
 
 export function encodeMessage <T> (message: T, codec: Codec<T>) {

packages/protons-runtime/src/index.ts

@@ -1,4 +1,4 @@
-import type { Codec } from './codecs/codec.js'
+import type { Codec } from './codec.js'
 
 export interface FieldDef {
   name: string
@@ -35,3 +35,4 @@ export { sint64 } from './codecs/sint64.js'
 export { string } from './codecs/string.js'
 export { uint32 } from './codecs/uint32.js'
 export { uint64 } from './codecs/uint64.js'
+export type { Codec } from './codec.js'

packages/protons-runtime/tsconfig.json

@@ -1,9 +1,7 @@
 {
   "extends": "aegir/src/config/tsconfig.aegir.json",
   "compilerOptions": {
-    "outDir": "dist",
-    "emitDeclarationOnly": false,
-    "module": "ES2020"
+    "outDir": "dist"
   },
   "include": [
     "src",

packages/protons/bin/protons.ts

@@ -6,13 +6,13 @@ import { generate } from '../src/index.js'
 async function main () {
   const cli = meow(`
   Usage
-    $ protons source
+    $ protons source...
 
   Options
-    --output, -o  Path to a directory to write transpiled typescript files into
+    --output, -o Path to a directory to write transpiled typescript files into
 
   Examples
-    $ protons ./path/to/file.proto
+    $ protons ./path/to/file.proto ./path/to/other/file.proto
 `, {
     importMeta: import.meta,
     flags: {

packages/protons/src/index.ts

@@ -141,8 +141,7 @@ export namespace ${messageDef.name} {
   export const codec = () => {
     return enumeration<typeof ${messageDef.name}>(${messageDef.name})
   }
-}
-`
+}`.trim()
   }
 
   let nested = ''
@@ -151,11 +150,10 @@ export namespace ${messageDef.name} {
     nested = '\n'
     nested += Object.values(messageDef.nested)
       .map(def => compileMessage(def, moduleDef).trim())
-      .join('\n')
+      .join('\n\n')
       .split('\n')
       .map(line => line.trim() === '' ? '' : `  ${line}`)
       .join('\n')
-    nested += '\n'
   }
 
   const fields = messageDef.fields ?? {}
@@ -164,18 +162,26 @@ export namespace ${messageDef.name} {
   moduleDef.imports.add('encodeMessage')
   moduleDef.imports.add('decodeMessage')
   moduleDef.imports.add('message')
+  moduleDef.importedTypes.add('Codec')
 
-  return `
+  const interfaceFields = defineFields(fields, messageDef, moduleDef)
+    .join('\n  ')
+    .trim()
+
+  let interfaceDef = ''
+  let interfaceCodecDef = ''
+
+  if (interfaceFields !== '') {
+    interfaceDef = `
 export interface ${messageDef.name} {
   ${
     defineFields(fields, messageDef, moduleDef)
       .join('\n  ')
       .trim()
   }
-}
-
-export namespace ${messageDef.name} {${nested}
-  export const codec = () => {
+}`
+    interfaceCodecDef = `
+  export const codec = (): Codec<${messageDef.name}> => {
     return message<${messageDef.name}>({
       ${Object.entries(fields)
       .map(([name, fieldDef]) => {
@@ -207,13 +213,21 @@ export namespace ${messageDef.name} {${nested}
 
   export const decode = (buf: Uint8Array): ${messageDef.name} => {
     return decodeMessage(buf, ${messageDef.name}.codec())
+  }`
   }
+
+  return `
+${interfaceDef}
+
+export namespace ${messageDef.name} {
+  ${`${nested}${nested !== '' && interfaceCodecDef !== '' ? '\n' : ''}${interfaceCodecDef}`.trim()}
 }
-`
+`.trimStart()
 }
 
 interface ModuleDef {
   imports: Set<string>
+  importedTypes: Set<string>
   types: Set<string>
   compiled: string[]
   globals: Record<string, ClassDef>
@@ -222,6 +236,7 @@ interface ModuleDef {
 function defineModule (def: ClassDef): ModuleDef {
   const moduleDef: ModuleDef = {
     imports: new Set(),
+    importedTypes: new Set(),
     types: new Set(),
     compiled: [],
     globals: {}
@@ -273,14 +288,27 @@ export async function generate (source: string, flags: any) {
   const def = JSON.parse(json)
   const moduleDef = defineModule(def)
 
-  const content = `
-/* eslint-disable import/export */
-/* eslint-disable @typescript-eslint/no-namespace */
+  let lines = [
+    '/* eslint-disable import/export */',
+    '/* eslint-disable @typescript-eslint/no-namespace */',
+    ''
+  ]
+
+  if (moduleDef.imports.size > 0) {
+    lines.push(`import { ${Array.from(moduleDef.imports).join(', ')} } from 'protons-runtime'`)
+  }
+
+  if (moduleDef.importedTypes.size > 0) {
+    lines.push(`import type { ${Array.from(moduleDef.importedTypes).join(', ')} } from 'protons-runtime'`)
+  }
 
-import { ${Array.from(moduleDef.imports).join(', ')} } from 'protons-runtime'
+  lines = [
+    ...lines,
+    '',
+    ...moduleDef.compiled
+  ]
 
-${moduleDef.compiled.map(str => str.trim()).join('\n\n').trim()}
-`.trim()
+  const content = lines.join('\n').trim()
 
   await fs.writeFile(pathWithExtension(source, '.ts'), content + '\n')
 }

packages/protons/test/fixtures/basic.ts

@@ -2,23 +2,26 @@
 /* eslint-disable @typescript-eslint/no-namespace */
 
 import { encodeMessage, decodeMessage, message, string, int32 } from 'protons-runtime'
+import type { Codec } from 'protons-runtime'
 
 export interface Basic {
   foo: string
   num: number
 }
 
 export namespace Basic {
-  export const codec = message<Basic>({
-    1: { name: 'foo', codec: string },
-    2: { name: 'num', codec: int32 }
-  })
+  export const codec = (): Codec<Basic> => {
+    return message<Basic>({
+      1: { name: 'foo', codec: string },
+      2: { name: 'num', codec: int32 }
+    })
+  }
 
   export const encode = (obj: Basic): Uint8Array => {
-    return encodeMessage(obj, Basic.codec)
+    return encodeMessage(obj, Basic.codec())
   }
 
   export const decode = (buf: Uint8Array): Basic => {
-    return decodeMessage(buf, Basic.codec)
+    return decodeMessage(buf, Basic.codec())
   }
 }