feat(tl-utils): support flag for exposing raw flags in codegen

packages/tl-utils/src/codegen/reader.ts

@@ -5,7 +5,7 @@ import { snakeToCamel } from './utils'
 /**
  * Returns code as an object entry
  */
-export function generateReaderCodeForTlEntry(entry: TlEntry): string {
+export function generateReaderCodeForTlEntry(entry: TlEntry, includeFlags = false): string {
     if (entry.id === 0) entry.id = computeConstructorIdFromEntry(entry)
 
     let ret = `${entry.id}:function(r){`
@@ -23,6 +23,11 @@ export function generateReaderCodeForTlEntry(entry: TlEntry): string {
             const code = `var ${arg.name}=r.uint();`
             ret = ret.replace('return{', code + 'return{')
             flagsFields[arg.name] = 1
+
+            if (includeFlags) {
+                ret += `${arg.name}:${arg.name},`
+            }
+
             return
         }
 

packages/tl-utils/src/codegen/types.ts

@@ -54,7 +54,8 @@ function entryFullTypeName(entry: TlEntry): string {
 export function generateTypescriptDefinitionsForTlEntry(
     entry: TlEntry,
     baseNamespace = 'tl.',
-    errors?: TlErrors
+    errors?: TlErrors,
+    withFlags = false
 ): string {
     let ret = ''
 
@@ -86,17 +87,34 @@ export function generateTypescriptDefinitionsForTlEntry(
     }
     if (comment) ret += jsComment(comment) + '\n'
 
-    ret += `interface ${entryFullTypeName(entry)} {\n    _: '${entry.name}';\n`
+    let genericsString = ''
+    const genericsIndex: Record<string, 1> = {}
+    if (entry.generics?.length) {
+        genericsString = '<'
+        entry.generics.forEach((it, idx) => {
+            const tsType =
+                it.type === 'Type'
+                    ? 'tl.TlObject'
+                    : fullTypeName(it.type, baseNamespace)
 
-    const genericsIndex: Record<string, string> = {}
+            genericsIndex[it.name] = 1
-    if (entry.generics) {
+            if (idx !== 0) genericsString += ', '
-        entry.generics.forEach((it) => {
+            genericsString += `${it.name} extends ${tsType}`
-            genericsIndex[it.name] = it.type
         })
+        genericsString += '>'
     }
 
+    ret += `interface ${entryFullTypeName(entry)}${genericsString} {\n    _: '${
+        entry.name
+    }';\n`
+
     entry.arguments.forEach((arg) => {
-        if (arg.type === '#') return
+        if (arg.type === '#') {
+            if (withFlags) {
+                ret += `    ${arg.name}: number;\n`
+            }
+            return
+        }
 
         if (arg.comment) {
             ret += indent(4, jsComment(arg.comment)) + '\n'
@@ -112,13 +130,8 @@ export function generateTypescriptDefinitionsForTlEntry(
         if (type[0] === '!') type = type.substr(1)
 
         if (type in genericsIndex) {
-            type = genericsIndex[type]
-
-            if (type === 'Type') {
-                type = 'any'
             typeFinal = true
         }
-        }
 
         if (!typeFinal) type = fullTypeName(arg.type, baseNamespace)
 

packages/tl-utils/src/codegen/writer.ts

@@ -14,7 +14,10 @@ export const TL_WRITER_PRELUDE =
  *
  * `h` (has) function should be available
  */
-export function generateWriterCodeForTlEntry(entry: TlEntry): string {
+export function generateWriterCodeForTlEntry(
+    entry: TlEntry,
+    withFlags = false
+): string {
     if (entry.id === 0) entry.id = computeConstructorIdFromEntry(entry)
 
     let ret = `'${entry.name}':function(w${
@@ -27,7 +30,7 @@ export function generateWriterCodeForTlEntry(entry: TlEntry): string {
 
     entry.arguments.forEach((arg) => {
         if (arg.type === '#') {
-            ret += `var ${arg.name}=0;`
+            ret += `var ${arg.name}=${withFlags ? `v.${arg.name}` : '0'};`
 
             entry.arguments.forEach((arg1) => {
                 let s
@@ -99,14 +102,15 @@ export function generateWriterCodeForTlEntry(entry: TlEntry): string {
 export function generateWriterCodeForTlEntries(
     entries: TlEntry[],
     varName: string,
-    prelude = true
+    prelude = true,
+    withFlags = false
 ): string {
     let ret = ''
     if (prelude) ret += TL_WRITER_PRELUDE
     ret += `var ${varName}={\n`
 
     entries.forEach((entry) => {
-        ret += generateWriterCodeForTlEntry(entry) + '\n'
+        ret += generateWriterCodeForTlEntry(entry, withFlags) + '\n'
     })
 
     return ret + '}'

packages/tl-utils/tests/codegen/reader.spec.ts

@@ -121,4 +121,19 @@ describe('generateReaderCodeForTlEntry', () => {
             '}'
         )
     })
+
+    it('generates code with raw flags for constructors with flags', () => {
+        const entry = parseTlToEntries('test flags:# flags2:# = Test;')[0]
+        expect(generateReaderCodeForTlEntry(entry, true)).eq(
+            `${entry.id}:function(r){${[
+                'var flags=r.uint();',
+                'var flags2=r.uint();',
+                'return{',
+                "_:'test',",
+                'flags:flags,',
+                'flags2:flags2,',
+                '}',
+            ].join('')}},`
+        )
+    })
 })

packages/tl-utils/tests/codegen/types.spec.ts

@@ -131,10 +131,30 @@ describe('generateTypescriptDefinitionsForTlEntry', () => {
             '---functions---\ninvokeWithoutUpdates#bf9459b7 {X:Type} query:!X = X;',
             'interface RawInvokeWithoutUpdatesRequest<X extends tl.TlObject> {',
             "    _: 'invokeWithoutUpdates';",
-            "    query: X;",
+            '    query: X;',
             '}'
         )
     })
+
+    it('generates code with raw flags for constructors with flags', () => {
+        const entry = parseTlToEntries('test flags:# flags2:# = Test;')[0]
+        expect(
+            generateTypescriptDefinitionsForTlEntry(
+                entry,
+                undefined,
+                undefined,
+                true
+            )
+        ).eq(
+            [
+                'interface RawTest {',
+                "    _: 'test';",
+                '    flags: number;',
+                '    flags2: number;',
+                '}',
+            ].join('\n')
+        )
+    })
 })
 
 describe('generateTypescriptDefinitionsForTlSchema', () => {
@@ -306,14 +326,16 @@ type TlObject =
     | tl.test.RawGetTestRequest
 `.trim(),
             ],
-            [`
+            [
+                `
 ns.isAnyTest = _isAny('Test');
 ns.test = {};
 (function(ns){
 ns.isAnyTest = _isAny('test.Test');
 })(ns.test);
 _types = JSON.parse('{"test":"Test","test2":"Test","test.test":"test.Test","test.test2":"test.Test"}');
-`.trim()]
+`.trim(),
+            ]
         )
     })
 })

packages/tl-utils/tests/codegen/writer.spec.ts

@@ -83,7 +83,7 @@ describe('generateWriterCodeForTlEntry', () => {
             'if(_timeout)w.int(v.timeout);',
             'var flags2=0;',
             'if(v.canDeleteChannel===true)flags2|=1;',
-            'w.uint(flags2);',
+            'w.uint(flags2);'
         )
     })
 
@@ -121,4 +121,17 @@ describe('generateWriterCodeForTlEntry', () => {
             'w.object(v.query);'
         )
     })
+
+    it('generates code with raw flags for constructors with flags', () => {
+        const entry = parseTlToEntries('test flags:# flags2:# = Test;')[0]
+        expect(generateWriterCodeForTlEntry(entry, true)).eq(
+            `'${entry.name}':function(w,v){${[
+                `w.uint(${entry.id});`,
+                'var flags=v.flags;',
+                'w.uint(flags);',
+                'var flags2=v.flags2;',
+                'w.uint(flags2);',
+            ].join('')}},`
+        )
+    })
 })