@sdkgen/typescript-generator 1.5.5 → 2.0.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (9) hide show
  1. package/dist/spec/helpers.spec.js +26 -22
  2. package/dist/src/browser-client.js +7 -7
  3. package/dist/src/helpers.d.ts +3 -3
  4. package/dist/src/helpers.js +14 -9
  5. package/dist/src/interfaces.js +2 -2
  6. package/dist/src/node-client.js +8 -7
  7. package/dist/src/node-server.js +7 -15
  8. package/dist/tsconfig.tsbuildinfo +1 -1510
  9. package/package.json +9 -8
package/dist/spec/helpers.spec.js CHANGED
@@ -23,7 +23,8 @@ const parser = __importStar(require("@sdkgen/parser"));
23
23
  const helpers_1 = require("../src/helpers");
24
24
  describe("helpers.ts", () => {
25
25
  test("generateTypescriptInterface", () => {
26
- const structType = new parser.StructType([
26
+ const structType = new parser.StructType([]);
27
+ structType.fields = [
27
28
  new parser.Field("int", new parser.IntPrimitiveType()),
28
29
  new parser.Field("bigint", new parser.BigIntPrimitiveType()),
29
30
  new parser.Field("date", new parser.DatePrimitiveType()),
@@ -33,9 +34,9 @@ describe("helpers.ts", () => {
33
34
  new parser.Field("void", new parser.VoidPrimitiveType()),
34
35
  new parser.Field("json", new parser.JsonPrimitiveType()),
35
36
  new parser.Field("optionalStrArray", new parser.OptionalType(new parser.ArrayType(new parser.StringPrimitiveType()))),
36
- ], []);
37
+ ];
37
38
  structType.name = "awesomeInterface";
38
- expect(helpers_1.generateTypescriptInterface(structType)).toBe(`export interface awesomeInterface {
39
+ expect((0, helpers_1.generateTypescriptInterface)(structType, false)).toBe(`export interface awesomeInterface {
39
40
  int: number
40
41
  bigint: bigint
41
42
  date: Date
@@ -50,74 +51,77 @@ describe("helpers.ts", () => {
50
51
  });
51
52
  test("generateTypescriptTypeName: IntPrimitiveType", () => {
52
53
  const type = new parser.IntPrimitiveType();
53
- expect(helpers_1.generateTypescriptTypeName(type)).toBe("number");
54
+ expect((0, helpers_1.generateTypescriptTypeName)(type, false)).toBe("number");
54
55
  });
55
56
  test("generateTypescriptTypeName: UIntPrimitiveType", () => {
56
57
  const type = new parser.UIntPrimitiveType();
57
- expect(helpers_1.generateTypescriptTypeName(type)).toBe("number");
58
+ expect((0, helpers_1.generateTypescriptTypeName)(type, false)).toBe("number");
58
59
  });
59
60
  test("generateTypescriptTypeName: MoneyPrimitiveType", () => {
60
61
  const type = new parser.MoneyPrimitiveType();
61
- expect(helpers_1.generateTypescriptTypeName(type)).toBe("number");
62
+ expect((0, helpers_1.generateTypescriptTypeName)(type, false)).toBe("number");
62
63
  });
63
64
  test("generateTypescriptTypeName: FloatPrimitiveType", () => {
64
65
  const type = new parser.FloatPrimitiveType();
65
- expect(helpers_1.generateTypescriptTypeName(type)).toBe("number");
66
+ expect((0, helpers_1.generateTypescriptTypeName)(type, false)).toBe("number");
66
67
  });
67
68
  test("generateTypescriptTypeName: DateTimePrimitiveType", () => {
68
69
  const type = new parser.DateTimePrimitiveType();
69
- expect(helpers_1.generateTypescriptTypeName(type)).toBe("Date");
70
+ expect((0, helpers_1.generateTypescriptTypeName)(type, false)).toBe("Date");
70
71
  });
71
72
  test("generateTypescriptTypeName: StringPrimitiveType", () => {
72
73
  const type = new parser.StringPrimitiveType();
73
- expect(helpers_1.generateTypescriptTypeName(type)).toBe("string");
74
+ expect((0, helpers_1.generateTypescriptTypeName)(type, false)).toBe("string");
74
75
  });
75
76
  test("generateTypescriptTypeName: CpfPrimitiveType", () => {
76
77
  const type = new parser.CpfPrimitiveType();
77
- expect(helpers_1.generateTypescriptTypeName(type)).toBe("string");
78
+ expect((0, helpers_1.generateTypescriptTypeName)(type, false)).toBe("string");
78
79
  });
79
80
  test("generateTypescriptTypeName: CnpjPrimitiveType", () => {
80
81
  const type = new parser.CnpjPrimitiveType();
81
- expect(helpers_1.generateTypescriptTypeName(type)).toBe("string");
82
+ expect((0, helpers_1.generateTypescriptTypeName)(type, false)).toBe("string");
82
83
  });
83
84
  test("generateTypescriptTypeName: EmailPrimitiveType", () => {
84
85
  const type = new parser.EmailPrimitiveType();
85
- expect(helpers_1.generateTypescriptTypeName(type)).toBe("string");
86
+ expect((0, helpers_1.generateTypescriptTypeName)(type, false)).toBe("string");
86
87
  });
87
88
  test("generateTypescriptTypeName: HtmlPrimitiveType", () => {
88
89
  const type = new parser.HtmlPrimitiveType();
89
- expect(helpers_1.generateTypescriptTypeName(type)).toBe("string");
90
+ expect((0, helpers_1.generateTypescriptTypeName)(type, false)).toBe("string");
90
91
  });
91
92
  test("generateTypescriptTypeName: UrlPrimitiveType", () => {
92
93
  const type = new parser.UrlPrimitiveType();
93
- expect(helpers_1.generateTypescriptTypeName(type)).toBe("string");
94
+ expect((0, helpers_1.generateTypescriptTypeName)(type, false)).toBe("string");
94
95
  });
95
96
  test("generateTypescriptTypeName: HexPrimitiveType", () => {
96
97
  const type = new parser.HexPrimitiveType();
97
- expect(helpers_1.generateTypescriptTypeName(type)).toBe("string");
98
+ expect((0, helpers_1.generateTypescriptTypeName)(type, false)).toBe("string");
98
99
  });
99
100
  test("generateTypescriptTypeName: Base64PrimitiveType", () => {
100
101
  const type = new parser.Base64PrimitiveType();
101
- expect(helpers_1.generateTypescriptTypeName(type)).toBe("string");
102
+ expect((0, helpers_1.generateTypescriptTypeName)(type, false)).toBe("string");
102
103
  });
103
104
  test("generateTypescriptTypeName: XmlPrimitiveType", () => {
104
105
  const type = new parser.XmlPrimitiveType();
105
- expect(helpers_1.generateTypescriptTypeName(type)).toBe("string");
106
+ expect((0, helpers_1.generateTypescriptTypeName)(type, false)).toBe("string");
106
107
  });
107
108
  test("generateTypescriptTypeName: StructType", () => {
108
- const structType = new parser.StructType([new parser.Field("int", new parser.IntPrimitiveType()), new parser.Field("bigint", new parser.BigIntPrimitiveType())], []);
109
+ const structType = new parser.StructType([
110
+ new parser.Field("int", new parser.IntPrimitiveType()),
111
+ new parser.Field("bigint", new parser.BigIntPrimitiveType()),
112
+ ]);
109
113
  structType.name = "simpleInterface";
110
- expect(helpers_1.generateTypescriptTypeName(structType)).toBe(structType.name);
114
+ expect((0, helpers_1.generateTypescriptTypeName)(structType, false)).toBe(structType.name);
111
115
  });
112
116
  test("generateTypescriptTypeName: EnumType", () => {
113
117
  const enumType = new parser.EnumType([new parser.EnumValue("value1")]);
114
118
  enumType.name = "simpleEnum";
115
- expect(helpers_1.generateTypescriptTypeName(enumType)).toBe(enumType.name);
119
+ expect((0, helpers_1.generateTypescriptTypeName)(enumType, false)).toBe(enumType.name);
116
120
  });
117
121
  test("generateTypescriptTypeName: TypeReference", () => {
118
122
  const enumType = new parser.TypeReference("typeRef");
119
123
  enumType.type = new parser.HexPrimitiveType();
120
- expect(helpers_1.generateTypescriptTypeName(enumType)).toBe("string");
124
+ expect((0, helpers_1.generateTypescriptTypeName)(enumType, false)).toBe("string");
121
125
  });
122
126
  test("generateTypescriptTypeName: unknown PrimitiveType error", () => {
123
127
  class UnknownType extends parser.Type {
@@ -127,6 +131,6 @@ describe("helpers.ts", () => {
127
131
  }
128
132
  }
129
133
  const newUnknownType = new UnknownType();
130
- expect(() => helpers_1.generateTypescriptTypeName(newUnknownType)).toThrowError(`BUG: generateTypescriptTypeName with ${newUnknownType.name}`);
134
+ expect(() => (0, helpers_1.generateTypescriptTypeName)(newUnknownType, false)).toThrowError(`BUG: generateTypescriptTypeName with ${newUnknownType.name}`);
131
135
  });
132
136
  });
package/dist/src/browser-client.js CHANGED
@@ -11,15 +11,15 @@ import { SdkgenError${hasErrorWithData ? ", SdkgenErrorWithData" : ""}, SdkgenHt
11
11
 
12
12
  `;
13
13
  for (const type of ast.enumTypes) {
14
- code += helpers_1.generateTypescriptEnum(type);
14
+ code += (0, helpers_1.generateTypescriptEnum)(type);
15
15
  code += "\n";
16
16
  }
17
17
  for (const type of ast.structTypes) {
18
- code += helpers_1.generateTypescriptInterface(type);
18
+ code += (0, helpers_1.generateTypescriptInterface)(type, true);
19
19
  code += "\n";
20
20
  }
21
21
  for (const error of ast.errors) {
22
- code += helpers_1.generateTypescriptErrorClass(error);
22
+ code += (0, helpers_1.generateTypescriptErrorClass)(error, true);
23
23
  code += "\n";
24
24
  }
25
25
  code += `export class ApiClient extends SdkgenHttpClient {
@@ -29,13 +29,13 @@ import { SdkgenError${hasErrorWithData ? ", SdkgenErrorWithData" : ""}, SdkgenHt
29
29
  ${ast.operations
30
30
  .filter(op => op.annotations.every(ann => !(ann instanceof parser_1.HiddenAnnotation)))
31
31
  .map(op => `
32
- ${op.prettyName}(args${op.args.length === 0 ? "?" : ""}: {${op.args
33
- .map(arg => `${arg.name}${arg.type.name.endsWith("?") ? "?" : ""}: ${helpers_1.generateTypescriptTypeName(arg.type)}`)
34
- .join(", ")}}): Promise<${helpers_1.generateTypescriptTypeName(op.returnType)}> { return this.makeRequest("${op.prettyName}", args || {}); }`)
32
+ ${op.name}(args${op.args.length === 0 ? "?" : ""}: {${op.args
33
+ .map(arg => `${arg.name}${arg.type.name.endsWith("?") ? "?" : ""}: ${(0, helpers_1.generateTypescriptTypeName)(arg.type, true)}`)
34
+ .join(", ")}}): Promise<${(0, helpers_1.generateTypescriptTypeName)(op.returnType, true)}> { return this.makeRequest("${op.name}", args || {}); }`)
35
35
  .join("")}
36
36
  }\n\n`;
37
37
  code += `const errClasses = {\n${ast.errors.map(err => ` ${err.name}`).join(",\n")}\n};\n\n`;
38
- code += `const astJson = ${JSON.stringify(parser_1.astToJson(ast), null, 4).replace(/"(?<key>\w+)":/gu, "$<key>:")} as const;\n`;
38
+ code += `const astJson = ${JSON.stringify((0, parser_1.astToJson)(ast), null, 4).replace(/"(?<key>\w+)":/gu, "$<key>:")} as const;\n`;
39
39
  return code;
40
40
  }
41
41
  exports.generateBrowserClientSource = generateBrowserClientSource;
package/dist/src/helpers.d.ts CHANGED
@@ -1,7 +1,7 @@
1
1
  import type { ErrorNode, Type } from "@sdkgen/parser";
2
2
  import { EnumType, StructType } from "@sdkgen/parser";
3
- export declare function generateTypescriptTypeName(type: Type): string;
4
- export declare function generateTypescriptInterface(type: StructType): string;
3
+ export declare function generateTypescriptTypeName(type: Type, isBrowser: boolean): string;
4
+ export declare function generateTypescriptInterface(type: StructType, isBrowser: boolean): string;
5
5
  export declare function generateTypescriptEnum(type: EnumType): string;
6
- export declare function generateTypescriptErrorClass(error: ErrorNode): string;
6
+ export declare function generateTypescriptErrorClass(error: ErrorNode, isBrowser: boolean): string;
7
7
  export declare function clearForLogging(path: string, type: Type): string;
package/dist/src/helpers.js CHANGED
@@ -2,7 +2,7 @@
2
2
  Object.defineProperty(exports, "__esModule", { value: true });
3
3
  exports.clearForLogging = exports.generateTypescriptErrorClass = exports.generateTypescriptEnum = exports.generateTypescriptInterface = exports.generateTypescriptTypeName = void 0;
4
4
  const parser_1 = require("@sdkgen/parser");
5
- function generateTypescriptTypeName(type) {
5
+ function generateTypescriptTypeName(type, isBrowser) {
6
6
  switch (type.constructor) {
7
7
  case parser_1.IntPrimitiveType:
8
8
  case parser_1.UIntPrimitiveType:
@@ -17,7 +17,7 @@ function generateTypescriptTypeName(type) {
17
17
  case parser_1.BoolPrimitiveType:
18
18
  return "boolean";
19
19
  case parser_1.BytesPrimitiveType:
20
- return "Buffer";
20
+ return isBrowser ? "ArrayBuffer" : "Buffer";
21
21
  case parser_1.StringPrimitiveType:
22
22
  case parser_1.CpfPrimitiveType:
23
23
  case parser_1.CnpjPrimitiveType:
@@ -34,10 +34,10 @@ function generateTypescriptTypeName(type) {
34
34
  case parser_1.JsonPrimitiveType:
35
35
  return "any";
36
36
  case parser_1.OptionalType:
37
- return `${generateTypescriptTypeName(type.base)} | null`;
37
+ return `${generateTypescriptTypeName(type.base, isBrowser)} | null`;
38
38
  case parser_1.ArrayType: {
39
39
  const { base } = type;
40
- const baseGen = generateTypescriptTypeName(base);
40
+ const baseGen = generateTypescriptTypeName(base, isBrowser);
41
41
  if (base instanceof parser_1.OptionalType) {
42
42
  return `(${baseGen})[]`;
43
43
  }
@@ -47,24 +47,29 @@ function generateTypescriptTypeName(type) {
47
47
  case parser_1.EnumType:
48
48
  return type.name;
49
49
  case parser_1.TypeReference:
50
- return generateTypescriptTypeName(type.type);
50
+ return generateTypescriptTypeName(type.type, isBrowser);
51
51
  default:
52
52
  throw new Error(`BUG: generateTypescriptTypeName with ${type.constructor.name}`);
53
53
  }
54
54
  }
55
55
  exports.generateTypescriptTypeName = generateTypescriptTypeName;
56
- function generateTypescriptInterface(type) {
56
+ function generateTypescriptInterface(type, isBrowser) {
57
57
  return `export interface ${type.name} {
58
- ${type.fields.map(field => ` ${field.name}: ${generateTypescriptTypeName(field.type)}`).join("\n")}
58
+ ${type.fields.map(field => ` ${field.name}: ${generateTypescriptTypeName(field.type, isBrowser)}`).join("\n")}
59
59
  }\n`;
60
60
  }
61
61
  exports.generateTypescriptInterface = generateTypescriptInterface;
62
62
  function generateTypescriptEnum(type) {
63
+ if (type.hasStructValues) {
64
+ return `export type ${type.name} = ${type.values
65
+ .map(x => (x.struct ? `({tag: "${x.value}"} & ${x.struct.name})` : `{tag: "${x.value}"}`))
66
+ .join(" | ")};\n`;
67
+ }
63
68
  return `export type ${type.name} = ${type.values.map(x => `"${x.value}"`).join(" | ")};\n`;
64
69
  }
65
70
  exports.generateTypescriptEnum = generateTypescriptEnum;
66
- function generateTypescriptErrorClass(error) {
67
- return `export class ${error.name} extends ${error.dataType instanceof parser_1.VoidPrimitiveType ? "SdkgenError" : `SdkgenErrorWithData<${generateTypescriptTypeName(error.dataType)}>`} {}\n`;
71
+ function generateTypescriptErrorClass(error, isBrowser) {
72
+ return `export class ${error.name} extends ${error.dataType instanceof parser_1.VoidPrimitiveType ? "SdkgenError" : `SdkgenErrorWithData<${generateTypescriptTypeName(error.dataType, isBrowser)}>`} {}\n`;
68
73
  }
69
74
  exports.generateTypescriptErrorClass = generateTypescriptErrorClass;
70
75
  function clearForLogging(path, type) {
package/dist/src/interfaces.js CHANGED
@@ -5,11 +5,11 @@ const helpers_1 = require("./helpers");
5
5
  function generateTypescriptInterfaces(ast) {
6
6
  let code = "";
7
7
  for (const type of ast.enumTypes) {
8
- code += helpers_1.generateTypescriptEnum(type);
8
+ code += (0, helpers_1.generateTypescriptEnum)(type);
9
9
  }
10
10
  code += "\n";
11
11
  for (const type of ast.structTypes) {
12
- code += helpers_1.generateTypescriptInterface(type);
12
+ code += (0, helpers_1.generateTypescriptInterface)(type, false);
13
13
  code += "\n";
14
14
  }
15
15
  return code;
package/dist/src/node-client.js CHANGED
@@ -9,22 +9,23 @@ function generateNodeClientSource(ast) {
9
9
  const hasErrorWithoutData = ast.errors.filter(err => err.name !== "Fatal").some(err => err.dataType instanceof parser_1.VoidPrimitiveType);
10
10
  code += `/* eslint-disable */
11
11
  import { Context, Fatal${hasErrorWithoutData ? ", SdkgenError" : ""}${hasErrorWithData ? ", SdkgenErrorWithData" : ""}, SdkgenHttpClient } from "@sdkgen/node-runtime";
12
+ import { PartialDeep } from "type-fest";
12
13
  export { Fatal } from "@sdkgen/node-runtime";
13
14
 
14
15
  `;
15
16
  for (const type of ast.enumTypes) {
16
- code += helpers_1.generateTypescriptEnum(type);
17
+ code += (0, helpers_1.generateTypescriptEnum)(type);
17
18
  code += "\n";
18
19
  }
19
20
  for (const type of ast.structTypes) {
20
- code += helpers_1.generateTypescriptInterface(type);
21
+ code += (0, helpers_1.generateTypescriptInterface)(type, false);
21
22
  code += "\n";
22
23
  }
23
24
  for (const error of ast.errors) {
24
25
  if (error.name === "Fatal") {
25
26
  continue;
26
27
  }
27
- code += helpers_1.generateTypescriptErrorClass(error);
28
+ code += (0, helpers_1.generateTypescriptErrorClass)(error, false);
28
29
  code += "\n";
29
30
  }
30
31
  code += `export class ApiClient extends SdkgenHttpClient {
@@ -34,13 +35,13 @@ export { Fatal } from "@sdkgen/node-runtime";
34
35
  ${ast.operations
35
36
  .filter(op => op.annotations.every(ann => !(ann instanceof parser_1.HiddenAnnotation)))
36
37
  .map(op => `
37
- ${op.prettyName}(ctx: Context | null, args: {${op.args
38
- .map(arg => `${arg.name}${arg.type.name.endsWith("?") ? "?" : ""}: ${helpers_1.generateTypescriptTypeName(arg.type)}`)
39
- .join(", ")}}): Promise<${helpers_1.generateTypescriptTypeName(op.returnType)}> { return this.makeRequest(ctx, "${op.prettyName}", args); }`)
38
+ ${op.name}(ctx: PartialDeep<Context> | null, args: {${op.args
39
+ .map(arg => `${arg.name}${arg.type.name.endsWith("?") ? "?" : ""}: ${(0, helpers_1.generateTypescriptTypeName)(arg.type, false)}`)
40
+ .join(", ")}}): Promise<${(0, helpers_1.generateTypescriptTypeName)(op.returnType, false)}> { return this.makeRequest(ctx, "${op.name}", args); }`)
40
41
  .join("")}
41
42
  }\n\n`;
42
43
  code += `const errClasses = {\n${ast.errors.map(err => ` ${err.name}`).join(",\n")}\n};\n\n`;
43
- code += `const astJson = ${JSON.stringify(parser_1.astToJson(ast), null, 4).replace(/"(?<key>\w+)":/gu, "$<key>:")} as const;\n`;
44
+ code += `const astJson = ${JSON.stringify((0, parser_1.astToJson)(ast), null, 4).replace(/"(?<key>\w+)":/gu, "$<key>:")} as const;\n`;
44
45
  return code;
45
46
  }
46
47
  exports.generateNodeClientSource = generateNodeClientSource;
package/dist/src/node-server.js CHANGED
@@ -13,38 +13,30 @@ export { Fatal } from "@sdkgen/node-runtime";
13
13
 
14
14
  `;
15
15
  for (const type of ast.enumTypes) {
16
- code += helpers_1.generateTypescriptEnum(type);
16
+ code += (0, helpers_1.generateTypescriptEnum)(type);
17
17
  code += "\n";
18
18
  }
19
19
  for (const type of ast.structTypes) {
20
- code += helpers_1.generateTypescriptInterface(type);
20
+ code += (0, helpers_1.generateTypescriptInterface)(type, false);
21
21
  code += "\n";
22
22
  }
23
23
  for (const error of ast.errors) {
24
24
  if (error.name === "Fatal") {
25
25
  continue;
26
26
  }
27
- code += helpers_1.generateTypescriptErrorClass(error);
27
+ code += (0, helpers_1.generateTypescriptErrorClass)(error, false);
28
28
  code += "\n";
29
29
  }
30
30
  code += `export class ApiConfig<ExtraContextT> extends BaseApiConfig<ExtraContextT> {
31
31
  fn!: {${ast.operations
32
32
  .map(op => `
33
- ${op.prettyName}: (ctx: Context & ExtraContextT, args: {${op.args
34
- .map(arg => `${arg.name}: ${helpers_1.generateTypescriptTypeName(arg.type)}`)
35
- .join(", ")}}) => Promise<${helpers_1.generateTypescriptTypeName(op.returnType)}>`)
33
+ ${op.name}: (ctx: Context & ExtraContextT, args: {${op.args
34
+ .map(arg => `${arg.name}: ${(0, helpers_1.generateTypescriptTypeName)(arg.type, false)}`)
35
+ .join(", ")}}) => Promise<${(0, helpers_1.generateTypescriptTypeName)(op.returnType, false)}>`)
36
36
  .join("")}
37
37
  }
38
38
 
39
- /** @deprecated api.err shouldn't be used. Import and throw errors directly. */
40
- err = {${ast.errors
41
- .filter(err => err.dataType instanceof parser_1.VoidPrimitiveType)
42
- .map(err => `
43
- ${err.name}(message: string = "") { throw new ${err.name}(message); }`)
44
- .join(",")}
45
- }
46
-
47
- astJson = ${JSON.stringify(parser_1.astToJson(ast), null, 4)
39
+ astJson = ${JSON.stringify((0, parser_1.astToJson)(ast), null, 4)
48
40
  .replace(/"(?<key>\w+)":/gu, "$<key>:")
49
41
  .replace(/\n/gu, "\n ")} as const
50
42
  }