conjure-typescript - npm Package Compare versions

Comparing version 5.3.0 to 5.4.0

lib/commands/generate/errorGenerator.d.ts

@@ -19,2 +19,3 @@ /**
 import { SimpleAst } from "./simpleAst";
-export declare function generateError(definition: IErrorDefinition, knownTypes: Map<string, ITypeDefinition>, simpleAst: SimpleAst): Promise<void>;
+import { ITypeGenerationFlags } from "./typeGenerationFlags";
+export declare function generateError(definition: IErrorDefinition, knownTypes: Map<string, ITypeDefinition>, simpleAst: SimpleAst, typeGenerationFlags: ITypeGenerationFlags): Promise<void>;

lib/commands/generate/errorGenerator.js

@@ -24,8 +24,8 @@ "use strict";
 var utils_1 = require("./utils");
-function generateError(definition, knownTypes, simpleAst) {
+function generateError(definition, knownTypes, simpleAst, typeGenerationFlags) {
     var sourceFile = simpleAst.createSourceFile(definition.errorName);
     var interfaceName = "I" + definition.errorName.name;
     var errorName = definition.namespace + ":" + definition.errorName.name;
-    var tsTypeVisitor = new tsReturnTypeVisitor_1.TsReturnTypeVisitor(knownTypes, definition.errorName, false);
-    var importsVisitor = new imports_1.ImportsVisitor(knownTypes, definition.errorName);
+    var tsTypeVisitor = new tsReturnTypeVisitor_1.TsReturnTypeVisitor(knownTypes, definition.errorName, false, typeGenerationFlags);
+    var importsVisitor = new imports_1.ImportsVisitor(knownTypes, definition.errorName, typeGenerationFlags);
     var imports = [];
@@ -32,0 +32,0 @@ var args = definition.safeArgs.concat(definition.unsafeArgs);

lib/commands/generate/generateCommand.d.ts

@@ -30,2 +30,6 @@ /**
     productDependencies?: string;
+    /**
+     * Generates flavoured types for compatible aliases (string, rids...)
+     */
+    flavorizedAliases?: boolean;
 }
@@ -32,0 +36,0 @@ export interface ITsConfig {

lib/commands/generate/generateCommand.js

@@ -88,3 +88,5 @@ "use strict";
                         _b = _c.sent(), conjureDefinition = _b.conjureDefinition, packageJson = _b.packageJson, tsConfig = _b.tsConfig, gitIgnore = _b.gitIgnore;
-                        generatePromise = (0, generator_1.generate)(conjureDefinition, output);
+                        generatePromise = (0, generator_1.generate)(conjureDefinition, output, {
+                            flavorizedAliases: !!args.flavorizedAliases,
+                        });
                         if (rawSource) {
@@ -121,2 +123,7 @@ return [2 /*return*/, generatePromise];
         })
+            .option("flavorizedAliases", {
+            default: false,
+            describe: "Generates flavoured types for compatible aliases.",
+            type: "boolean",
+        })
             .option("nodeCompatibleModules", {
@@ -123,0 +130,0 @@ default: false,

lib/commands/generate/generator.d.ts

@@ -18,2 +18,3 @@ /**
 import { IConjureDefinition } from "conjure-api";
-export declare function generate(definition: IConjureDefinition, outDir: string): Promise<void>;
+import { ITypeGenerationFlags } from "./typeGenerationFlags";
+export declare function generate(definition: IConjureDefinition, outDir: string, typeGenerationFlags: ITypeGenerationFlags): Promise<void>;

lib/commands/generate/generator.js

@@ -66,3 +66,3 @@ "use strict";
 var utils_1 = require("./utils");
-function generate(definition, outDir) {
+function generate(definition, outDir, typeGenerationFlags) {
     return __awaiter(this, void 0, void 0, function () {
@@ -95,6 +95,10 @@ var knownTypes, indexingVisitor, knownDefinitions, promises, simpleAst;
                     definition.services.forEach(function (serviceDefinition) {
-                        return promises.push((0, serviceGenerator_1.generateService)(serviceDefinition, knownTypes, simpleAst));
+                        return promises.push((0, serviceGenerator_1.generateService)(serviceDefinition, knownTypes, simpleAst, typeGenerationFlags));
                     });
-                    definition.types.forEach(function (typeDefinition) { return promises.push((0, typeGenerator_1.generateType)(typeDefinition, knownTypes, simpleAst)); });
-                    definition.errors.forEach(function (errorDefinition) { return promises.push((0, errorGenerator_1.generateError)(errorDefinition, knownTypes, simpleAst)); });
+                    definition.types.forEach(function (typeDefinition) {
+                        return promises.push((0, typeGenerator_1.generateType)(typeDefinition, knownTypes, simpleAst, typeGenerationFlags));
+                    });
+                    definition.errors.forEach(function (errorDefinition) {
+                        return promises.push((0, errorGenerator_1.generateError)(errorDefinition, knownTypes, simpleAst, typeGenerationFlags));
+                    });
                     promises.push(simpleAst.generateIndexFiles());
@@ -101,0 +105,0 @@ return [2 /*return*/, Promise.all(promises)

lib/commands/generate/imports.d.ts

@@ -19,7 +19,9 @@ /**
 import { ImportDeclarationStructure } from "ts-simple-ast";
+import { ITypeGenerationFlags } from "./typeGenerationFlags";
 export declare class ImportsVisitor implements ITypeVisitor<ImportDeclarationStructure[]> {
     private knownTypes;
     private currType;
+    private typeGenerationFlags;
     private tsTypeVisitor;
-    constructor(knownTypes: Map<string, ITypeDefinition>, currType: ITypeName);
+    constructor(knownTypes: Map<string, ITypeDefinition>, currType: ITypeName, typeGenerationFlags: ITypeGenerationFlags);
     primitive: (_: PrimitiveType) => ImportDeclarationStructure[];
@@ -26,0 +28,0 @@ map: (obj: IMapType) => ImportDeclarationStructure[];

lib/commands/generate/imports.js

@@ -25,6 +25,7 @@ "use strict";
 var ImportsVisitor = /** @class */ (function () {
-    function ImportsVisitor(knownTypes, currType) {
+    function ImportsVisitor(knownTypes, currType, typeGenerationFlags) {
         var _this = this;
         this.knownTypes = knownTypes;
         this.currType = currType;
+        this.typeGenerationFlags = typeGenerationFlags;
         this.primitive = function (_) { return []; };
@@ -48,3 +49,4 @@ this.map = function (obj) {
             }
-            else if (conjure_api_1.ITypeDefinition.isAlias(typeDefinition)) {
+            else if (conjure_api_1.ITypeDefinition.isAlias(typeDefinition) &&
+                !(0, utils_1.isFlavorizable)(typeDefinition.alias.alias, _this.typeGenerationFlags.flavorizedAliases)) {
                 return conjure_api_1.IType.visit(typeDefinition.alias.alias, _this);
@@ -79,3 +81,3 @@ }
         };
-        this.tsTypeVisitor = new tsReturnTypeVisitor_1.TsReturnTypeVisitor(knownTypes, currType, false);
+        this.tsTypeVisitor = new tsReturnTypeVisitor_1.TsReturnTypeVisitor(knownTypes, currType, false, typeGenerationFlags);
     }
@@ -82,0 +84,0 @@ return ImportsVisitor;

lib/commands/generate/serviceGenerator.d.ts

@@ -19,2 +19,3 @@ /**
 import { SimpleAst } from "./simpleAst";
-export declare function generateService(definition: IServiceDefinition, knownTypes: Map<string, ITypeDefinition>, simpleAst: SimpleAst): Promise<void>;
+import { ITypeGenerationFlags } from "./typeGenerationFlags";
+export declare function generateService(definition: IServiceDefinition, knownTypes: Map<string, ITypeDefinition>, simpleAst: SimpleAst, typeGenerationFlags: ITypeGenerationFlags): Promise<void>;

lib/commands/generate/serviceGenerator.js

@@ -38,7 +38,7 @@ "use strict";
 var UNDEFINED_CONSTANT = "__undefined";
-function generateService(definition, knownTypes, simpleAst) {
+function generateService(definition, knownTypes, simpleAst, typeGenerationFlags) {
     var sourceFile = simpleAst.createSourceFile(definition.serviceName);
-    var tsReturnTypeVisitor = new tsReturnTypeVisitor_1.TsReturnTypeVisitor(knownTypes, definition.serviceName, true);
-    var tsArgumentTypeVisitor = new tsArgumentTypeVisitor_1.TsArgumentTypeVisitor(knownTypes, definition.serviceName, true);
-    var importsVisitor = new imports_1.ImportsVisitor(knownTypes, definition.serviceName);
+    var tsReturnTypeVisitor = new tsReturnTypeVisitor_1.TsReturnTypeVisitor(knownTypes, definition.serviceName, true, typeGenerationFlags);
+    var tsArgumentTypeVisitor = new tsArgumentTypeVisitor_1.TsArgumentTypeVisitor(knownTypes, definition.serviceName, true, typeGenerationFlags);
+    var importsVisitor = new imports_1.ImportsVisitor(knownTypes, definition.serviceName, typeGenerationFlags);
     var mediaTypeVisitor = new mediaTypeVisitor_1.MediaTypeVisitor(knownTypes);
@@ -45,0 +45,0 @@ var endpointSignatures = [];

lib/commands/generate/tsArgumentTypeVisitor.d.ts

@@ -19,6 +19,7 @@ /**
 import { TsReturnTypeVisitor } from "./tsReturnTypeVisitor";
+import { ITypeGenerationFlags } from "./typeGenerationFlags";
 export declare class TsArgumentTypeVisitor extends TsReturnTypeVisitor {
-    constructor(knownTypes: Map<string, ITypeDefinition>, currType: ITypeName, isTopLevelBinary: boolean);
+    constructor(knownTypes: Map<string, ITypeDefinition>, currType: ITypeName, isTopLevelBinary: boolean, typeGenerationFlags: ITypeGenerationFlags);
     primitive: (obj: PrimitiveType) => string;
     protected nestedVisitor: () => ITypeVisitor<string>;
 }

lib/commands/generate/tsArgumentTypeVisitor.js

@@ -39,4 +39,4 @@ "use strict";
     __extends(TsArgumentTypeVisitor, _super);
-    function TsArgumentTypeVisitor(knownTypes, currType, isTopLevelBinary) {
-        var _this = _super.call(this, knownTypes, currType, isTopLevelBinary) || this;
+    function TsArgumentTypeVisitor(knownTypes, currType, isTopLevelBinary, typeGenerationFlags) {
+        var _this = _super.call(this, knownTypes, currType, isTopLevelBinary, typeGenerationFlags) || this;
         _this.primitive = function (obj) {
@@ -67,3 +67,3 @@ switch (obj) {
         _this.nestedVisitor = function () {
-            return new TsArgumentTypeVisitor(_this.knownTypes, _this.currType, false);
+            return new TsArgumentTypeVisitor(_this.knownTypes, _this.currType, false, _this.typeGenerationFlags);
         };
@@ -70,0 +70,0 @@ return _this;

lib/commands/generate/tsReturnTypeVisitor.d.ts

@@ -18,2 +18,3 @@ /**
 import { IExternalReference, IListType, IMapType, IOptionalType, ISetType, IType, ITypeDefinition, ITypeName, ITypeVisitor, PrimitiveType } from "conjure-api";
+import { ITypeGenerationFlags } from "./typeGenerationFlags";
 export declare class TsReturnTypeVisitor implements ITypeVisitor<string> {
@@ -23,3 +24,4 @@ protected knownTypes: Map<string, ITypeDefinition>;
     protected isTopLevelBinary: boolean;
-    constructor(knownTypes: Map<string, ITypeDefinition>, currType: ITypeName, isTopLevelBinary: boolean);
+    protected typeGenerationFlags: ITypeGenerationFlags;
+    constructor(knownTypes: Map<string, ITypeDefinition>, currType: ITypeName, isTopLevelBinary: boolean, typeGenerationFlags: ITypeGenerationFlags);
     primitive: (obj: PrimitiveType) => string;
@@ -26,0 +28,0 @@ map: (obj: IMapType) => string;

lib/commands/generate/tsReturnTypeVisitor.js

@@ -23,3 +23,3 @@ "use strict";
 var TsReturnTypeVisitor = /** @class */ (function () {
-    function TsReturnTypeVisitor(knownTypes, currType, isTopLevelBinary) {
+    function TsReturnTypeVisitor(knownTypes, currType, isTopLevelBinary, typeGenerationFlags) {
         var _this = this;
@@ -29,2 +29,3 @@ this.knownTypes = knownTypes;
         this.isTopLevelBinary = isTopLevelBinary;
+        this.typeGenerationFlags = typeGenerationFlags;
         this.primitive = function (obj) {
@@ -58,4 +59,10 @@ switch (obj) {
                 var keyTypeDefinition = _this.knownTypes.get((0, utils_1.createHashableTypeName)(obj.keyType.reference));
-                if (keyTypeDefinition != null && conjure_api_1.ITypeDefinition.isEnum(keyTypeDefinition)) {
-                    return "{ [key in " + obj.keyType.reference.name + "]?: " + valueTsType + " }";
+                if (keyTypeDefinition != null) {
+                    if (conjure_api_1.ITypeDefinition.isEnum(keyTypeDefinition)) {
+                        return "{ [key in " + obj.keyType.reference.name + "]?: " + valueTsType + " }";
+                    }
+                    else if (conjure_api_1.ITypeDefinition.isAlias(keyTypeDefinition) &&
+                        (0, utils_1.isFlavorizable)(keyTypeDefinition.alias.alias, _this.typeGenerationFlags.flavorizedAliases)) {
+                        return "{ [key: I" + obj.keyType.reference.name + "]: " + valueTsType + " }";
+                    }
                 }
@@ -82,3 +89,4 @@ }
             }
-            else if (conjure_api_1.ITypeDefinition.isAlias(typeDefinition)) {
+            else if (conjure_api_1.ITypeDefinition.isAlias(typeDefinition) &&
+                !(0, utils_1.isFlavorizable)(typeDefinition.alias.alias, _this.typeGenerationFlags.flavorizedAliases)) {
                 return conjure_api_1.IType.visit(typeDefinition.alias.alias, _this);
@@ -105,3 +113,3 @@ }
         this.nestedVisitor = function () {
-            return new TsReturnTypeVisitor(_this.knownTypes, _this.currType, false);
+            return new TsReturnTypeVisitor(_this.knownTypes, _this.currType, false, _this.typeGenerationFlags);
         };
@@ -108,0 +116,0 @@ }

lib/commands/generate/typeGenerator.d.ts

@@ -17,8 +17,19 @@ /**
  */
-import { IEnumDefinition, IObjectDefinition, ITypeDefinition, IUnionDefinition } from "conjure-api";
+import { IAliasDefinition, IEnumDefinition, IObjectDefinition, ITypeDefinition, IUnionDefinition } from "conjure-api";
 import { SimpleAst } from "./simpleAst";
-export declare function generateType(definition: ITypeDefinition, knownTypes: Map<string, ITypeDefinition>, simpleAst: SimpleAst): Promise<void>;
+import { ITypeGenerationFlags } from "./typeGenerationFlags";
+export declare function generateType(definition: ITypeDefinition, knownTypes: Map<string, ITypeDefinition>, simpleAst: SimpleAst, typeGenerationFlags: ITypeGenerationFlags): Promise<void>;
 /**
  * Generates a file of the following format:
  * ```
+ *  export type ExampleAlias = string & {
+ *     __conjure_type?: "ExampleAlias";
+ *     __conjure_package?: "com.palantir.product";
+ *  };
+ * ```
+ */
+export declare function generateAlias(definition: IAliasDefinition, knownTypes: Map<string, ITypeDefinition>, simpleAst: SimpleAst, typeGenerationFlags: ITypeGenerationFlags): Promise<void>;
+/**
+ * Generates a file of the following format:
+ * ```
  * export namespace EnumExample {
@@ -48,3 +59,3 @@ *     export type ONE = "ONE";
  */
-export declare function generateObject(definition: IObjectDefinition, knownTypes: Map<string, ITypeDefinition>, simpleAst: SimpleAst): Promise<void>;
-export declare function generateUnion(definition: IUnionDefinition, knownTypes: Map<string, ITypeDefinition>, simpleAst: SimpleAst): Promise<void>;
+export declare function generateObject(definition: IObjectDefinition, knownTypes: Map<string, ITypeDefinition>, simpleAst: SimpleAst, typeGenerationFlags: ITypeGenerationFlags): Promise<void>;
+export declare function generateUnion(definition: IUnionDefinition, knownTypes: Map<string, ITypeDefinition>, simpleAst: SimpleAst, typeGenerationFlags: ITypeGenerationFlags): Promise<void>;

lib/commands/generate/typeGenerator.js

@@ -39,3 +39,3 @@ "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateUnion = exports.generateObject = exports.generateEnum = exports.generateType = void 0;
+exports.generateUnion = exports.generateObject = exports.generateEnum = exports.generateAlias = exports.generateType = void 0;
 /**
@@ -62,6 +62,5 @@ * @license
 var utils_1 = require("./utils");
-function generateType(definition, knownTypes, simpleAst) {
+function generateType(definition, knownTypes, simpleAst, typeGenerationFlags) {
     if (conjure_api_1.ITypeDefinition.isAlias(definition)) {
-        // TODO(gracew): implement at some point
-        return Promise.resolve();
+        return generateAlias(definition.alias, knownTypes, simpleAst, typeGenerationFlags);
     }
@@ -72,6 +71,6 @@ else if (conjure_api_1.ITypeDefinition.isEnum(definition)) {
     else if (conjure_api_1.ITypeDefinition.isObject(definition)) {
-        return generateObject(definition.object, knownTypes, simpleAst);
+        return generateObject(definition.object, knownTypes, simpleAst, typeGenerationFlags);
     }
     else if (conjure_api_1.ITypeDefinition.isUnion(definition)) {
-        return generateUnion(definition.union, knownTypes, simpleAst);
+        return generateUnion(definition.union, knownTypes, simpleAst, typeGenerationFlags);
     }
@@ -83,5 +82,45 @@ else {
 exports.generateType = generateType;
+var FLAVOR_TYPE_FIELD = "__conjure_type";
+var FLAVOR_PACKAGE_FIELD = "__conjure_package";
 /**
  * Generates a file of the following format:
  * ```
+ *  export type ExampleAlias = string & {
+ *     __conjure_type?: "ExampleAlias";
+ *     __conjure_package?: "com.palantir.product";
+ *  };
+ * ```
+ */
+function generateAlias(definition, knownTypes, simpleAst, typeGenerationFlags) {
+    return __awaiter(this, void 0, void 0, function () {
+        var tsTypeVisitor, fieldType, sourceFile, typeAlias;
+        return __generator(this, function (_a) {
+            if ((0, utils_1.isFlavorizable)(definition.alias, typeGenerationFlags.flavorizedAliases)) {
+                tsTypeVisitor = new tsReturnTypeVisitor_1.TsReturnTypeVisitor(knownTypes, definition.typeName, false, typeGenerationFlags);
+                fieldType = conjure_api_1.IType.visit(definition.alias, tsTypeVisitor);
+                sourceFile = simpleAst.createSourceFile(definition.typeName);
+                typeAlias = sourceFile.addTypeAlias({
+                    isExported: true,
+                    name: "I" + definition.typeName.name,
+                    type: [
+                        fieldType + " & {",
+                        "\t" + FLAVOR_TYPE_FIELD + "?: \"" + definition.typeName.name + "\",",
+                        "\t" + FLAVOR_PACKAGE_FIELD + "?: \"" + definition.typeName.package + "\",",
+                        "}",
+                    ].join("\n"),
+                });
+                if (definition.docs) {
+                    typeAlias.addJsDoc(definition.docs);
+                }
+                sourceFile.formatText();
+                return [2 /*return*/, sourceFile.save()];
+            }
+            return [2 /*return*/];
+        });
+    });
+}
+exports.generateAlias = generateAlias;
+/**
+ * Generates a file of the following format:
+ * ```
  * export namespace EnumExample {
@@ -170,8 +209,8 @@ *     export type ONE = "ONE";
  */
-function generateObject(definition, knownTypes, simpleAst) {
+function generateObject(definition, knownTypes, simpleAst, typeGenerationFlags) {
     return __awaiter(this, void 0, void 0, function () {
         var tsTypeVisitor, importsVisitor, properties, imports, sourceFile, iface;
         return __generator(this, function (_a) {
-            tsTypeVisitor = new tsReturnTypeVisitor_1.TsReturnTypeVisitor(knownTypes, definition.typeName, false);
-            importsVisitor = new imports_1.ImportsVisitor(knownTypes, definition.typeName);
+            tsTypeVisitor = new tsReturnTypeVisitor_1.TsReturnTypeVisitor(knownTypes, definition.typeName, false, typeGenerationFlags);
+            importsVisitor = new imports_1.ImportsVisitor(knownTypes, definition.typeName, typeGenerationFlags);
             properties = [];
@@ -212,3 +251,3 @@ imports = [];
 var visitor = "visitor";
-function generateUnion(definition, knownTypes, simpleAst) {
+function generateUnion(definition, knownTypes, simpleAst, typeGenerationFlags) {
     return __awaiter(this, void 0, void 0, function () {
@@ -218,3 +257,3 @@ var unionTsType, unionSourceFileInput, sourceFile, visitorInterface, variableStatement, objectLiteralExpr;
             unionTsType = "I" + definition.typeName.name;
-            unionSourceFileInput = processUnionMembers(unionTsType, definition, knownTypes);
+            unionSourceFileInput = processUnionMembers(unionTsType, definition, knownTypes, typeGenerationFlags);
             sourceFile = simpleAst.createSourceFile(definition.typeName);
@@ -277,5 +316,5 @@ if (unionSourceFileInput.imports.length !== 0) {
 exports.generateUnion = generateUnion;
-function processUnionMembers(unionTsType, definition, knownTypes) {
-    var tsTypeVisitor = new tsReturnTypeVisitor_1.TsReturnTypeVisitor(knownTypes, definition.typeName, false);
-    var importsVisitor = new imports_1.ImportsVisitor(knownTypes, definition.typeName);
+function processUnionMembers(unionTsType, definition, knownTypes, typeGenerationFlags) {
+    var tsTypeVisitor = new tsReturnTypeVisitor_1.TsReturnTypeVisitor(knownTypes, definition.typeName, false, typeGenerationFlags);
+    var importsVisitor = new imports_1.ImportsVisitor(knownTypes, definition.typeName, typeGenerationFlags);
     var imports = [];
@@ -282,0 +321,0 @@ var visitorProperties = [];

lib/commands/generate/utils.d.ts

@@ -17,3 +17,3 @@ /**
  */
-import { IEndpointDefinition, IEnumValueDefinition, IFieldDefinition, ITypeName } from "conjure-api";
+import { IEndpointDefinition, IEnumValueDefinition, IFieldDefinition, IType, ITypeName } from "conjure-api";
 export declare const CONJURE_CLIENT = "conjure-client";
@@ -31,2 +31,3 @@ export declare function doubleQuote(value: string): string;
 export declare function addIncubatingDocs(endpointDefinition: IEndpointDefinition, existingDocs: string[] | undefined): string[] | undefined;
+export declare function isFlavorizable(type: IType, flavorizedAliases: boolean): boolean;
 export {};

lib/commands/generate/utils.js

 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.addIncubatingDocs = exports.addDeprecatedToDocs = exports.isValidFunctionName = exports.dissasembleHashableTypeName = exports.createHashableTypeName = exports.singleQuote = exports.doubleQuote = exports.CONJURE_CLIENT = void 0;
+exports.isFlavorizable = exports.addIncubatingDocs = exports.addDeprecatedToDocs = exports.isValidFunctionName = exports.dissasembleHashableTypeName = exports.createHashableTypeName = exports.singleQuote = exports.doubleQuote = exports.CONJURE_CLIENT = void 0;
+/**
+ * @license
+ * Copyright 2018 Palantir Technologies, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+var conjure_api_1 = require("conjure-api");
 exports.CONJURE_CLIENT = "conjure-client";
@@ -106,2 +123,12 @@ function doubleQuote(value) {
 exports.addIncubatingDocs = addIncubatingDocs;
+var NON_FLAVORIZABLE_TYPES = new Set([
+    conjure_api_1.PrimitiveType.ANY,
+    conjure_api_1.PrimitiveType.BOOLEAN,
+    conjure_api_1.PrimitiveType.BINARY,
+    conjure_api_1.PrimitiveType.DATETIME,
+]);
+function isFlavorizable(type, flavorizedAliases) {
+    return flavorizedAliases && conjure_api_1.IType.isPrimitive(type) && !NON_FLAVORIZABLE_TYPES.has(type.primitive);
+}
+exports.isFlavorizable = isFlavorizable;
 //# sourceMappingURL=utils.js.map

package.json

 {
   "name": "conjure-typescript",
-  "version": "5.3.0",
+  "version": "5.4.0",
   "description": "A conjure generator for Typescript",
@@ -5,0 +5,0 @@ "bin": {

src/commands/generate/errorGenerator.ts

@@ -23,2 +23,3 @@ /**
 import { TsReturnTypeVisitor } from "./tsReturnTypeVisitor";
+import { ITypeGenerationFlags } from "./typeGenerationFlags";
 import { doubleQuote, singleQuote } from "./utils";
@@ -30,2 +31,3 @@
     simpleAst: SimpleAst,
+    typeGenerationFlags: ITypeGenerationFlags,
 ): Promise<void> {
@@ -35,4 +37,4 @@ const sourceFile = simpleAst.createSourceFile(definition.errorName);
     const errorName = `${definition.namespace}:${definition.errorName.name}`;
-    const tsTypeVisitor = new TsReturnTypeVisitor(knownTypes, definition.errorName, false);
-    const importsVisitor = new ImportsVisitor(knownTypes, definition.errorName);
+    const tsTypeVisitor = new TsReturnTypeVisitor(knownTypes, definition.errorName, false, typeGenerationFlags);
+    const importsVisitor = new ImportsVisitor(knownTypes, definition.errorName, typeGenerationFlags);
     const imports: ImportDeclarationStructure[] = [];
@@ -39,0 +41,0 @@

src/commands/generate/generateCommand.ts

@@ -56,2 +56,7 @@ /**
     productDependencies?: string;
+
+    /**
+     * Generates flavoured types for compatible aliases (string, rids...)
+     */
+    flavorizedAliases?: boolean;
 }
@@ -97,2 +102,7 @@
             })
+            .option("flavorizedAliases", {
+                default: false,
+                describe: "Generates flavoured types for compatible aliases.",
+                type: "boolean",
+            })
             .option("nodeCompatibleModules", {
@@ -120,4 +130,5 @@ default: false,
         const { conjureDefinition, packageJson, tsConfig, gitIgnore } = await this.parseCommandLineArguments(args);
-
-        const generatePromise = generate(conjureDefinition, output);
+        const generatePromise = generate(conjureDefinition, output, {
+            flavorizedAliases: !!args.flavorizedAliases,
+        });
         if (rawSource) {
@@ -124,0 +135,0 @@ return generatePromise;

src/commands/generate/generator.ts

@@ -34,6 +34,11 @@ /**
 import { SimpleAst } from "./simpleAst";
+import { ITypeGenerationFlags } from "./typeGenerationFlags";
 import { generateType } from "./typeGenerator";
 import { createHashableTypeName, dissasembleHashableTypeName } from "./utils";
 
-export async function generate(definition: IConjureDefinition, outDir: string) {
+export async function generate(
+    definition: IConjureDefinition,
+    outDir: string,
+    typeGenerationFlags: ITypeGenerationFlags,
+) {
     // Create project structure
@@ -61,6 +66,10 @@ const knownTypes = new Map();
     definition.services.forEach(serviceDefinition =>
-        promises.push(generateService(serviceDefinition, knownTypes, simpleAst)),
+        promises.push(generateService(serviceDefinition, knownTypes, simpleAst, typeGenerationFlags)),
     );
-    definition.types.forEach(typeDefinition => promises.push(generateType(typeDefinition, knownTypes, simpleAst)));
-    definition.errors.forEach(errorDefinition => promises.push(generateError(errorDefinition, knownTypes, simpleAst)));
+    definition.types.forEach(typeDefinition =>
+        promises.push(generateType(typeDefinition, knownTypes, simpleAst, typeGenerationFlags)),
+    );
+    definition.errors.forEach(errorDefinition =>
+        promises.push(generateError(errorDefinition, knownTypes, simpleAst, typeGenerationFlags)),
+    );
 
@@ -67,0 +76,0 @@ promises.push(simpleAst.generateIndexFiles());

src/commands/generate/imports.ts

@@ -33,8 +33,14 @@ /**
 import { TsReturnTypeVisitor } from "./tsReturnTypeVisitor";
-import { createHashableTypeName } from "./utils";
+import { ITypeGenerationFlags } from "./typeGenerationFlags";
+import { createHashableTypeName, isFlavorizable } from "./utils";
 
 export class ImportsVisitor implements ITypeVisitor<ImportDeclarationStructure[]> {
     private tsTypeVisitor: TsReturnTypeVisitor;
-    constructor(private knownTypes: Map<string, ITypeDefinition>, private currType: ITypeName) {
-        this.tsTypeVisitor = new TsReturnTypeVisitor(knownTypes, currType, false);
+
+    constructor(
+        private knownTypes: Map<string, ITypeDefinition>,
+        private currType: ITypeName,
+        private typeGenerationFlags: ITypeGenerationFlags,
+    ) {
+        this.tsTypeVisitor = new TsReturnTypeVisitor(knownTypes, currType, false, typeGenerationFlags);
     }
@@ -60,3 +66,6 @@
             throw new Error(`unknown reference type. package: '${obj.package}', name: '${obj.name}'`);
-        } else if (ITypeDefinition.isAlias(typeDefinition)) {
+        } else if (
+            ITypeDefinition.isAlias(typeDefinition) &&
+            !isFlavorizable(typeDefinition.alias.alias, this.typeGenerationFlags.flavorizedAliases)
+        ) {
             return IType.visit(typeDefinition.alias.alias, this);
@@ -63,0 +72,0 @@ } else if (obj.package === this.currType.package && obj.name === this.currType.name) {

src/commands/generate/serviceGenerator.ts

@@ -44,2 +44,3 @@ /**
 import { TsReturnTypeVisitor } from "./tsReturnTypeVisitor";
+import { ITypeGenerationFlags } from "./typeGenerationFlags";
 import { addDeprecatedToDocs, addIncubatingDocs, CONJURE_CLIENT } from "./utils";
@@ -62,7 +63,13 @@
     simpleAst: SimpleAst,
+    typeGenerationFlags: ITypeGenerationFlags,
 ): Promise<void> {
     const sourceFile = simpleAst.createSourceFile(definition.serviceName);
-    const tsReturnTypeVisitor = new TsReturnTypeVisitor(knownTypes, definition.serviceName, true);
-    const tsArgumentTypeVisitor = new TsArgumentTypeVisitor(knownTypes, definition.serviceName, true);
-    const importsVisitor = new ImportsVisitor(knownTypes, definition.serviceName);
+    const tsReturnTypeVisitor = new TsReturnTypeVisitor(knownTypes, definition.serviceName, true, typeGenerationFlags);
+    const tsArgumentTypeVisitor = new TsArgumentTypeVisitor(
+        knownTypes,
+        definition.serviceName,
+        true,
+        typeGenerationFlags,
+    );
+    const importsVisitor = new ImportsVisitor(knownTypes, definition.serviceName, typeGenerationFlags);
     const mediaTypeVisitor = new MediaTypeVisitor(knownTypes);
@@ -69,0 +76,0 @@

src/commands/generate/tsArgumentTypeVisitor.ts

@@ -20,6 +20,12 @@ /**
 import { TsReturnTypeVisitor } from "./tsReturnTypeVisitor";
+import { ITypeGenerationFlags } from "./typeGenerationFlags";
 
 export class TsArgumentTypeVisitor extends TsReturnTypeVisitor {
-    constructor(knownTypes: Map<string, ITypeDefinition>, currType: ITypeName, isTopLevelBinary: boolean) {
-        super(knownTypes, currType, isTopLevelBinary);
+    constructor(
+        knownTypes: Map<string, ITypeDefinition>,
+        currType: ITypeName,
+        isTopLevelBinary: boolean,
+        typeGenerationFlags: ITypeGenerationFlags,
+    ) {
+        super(knownTypes, currType, isTopLevelBinary, typeGenerationFlags);
     }
@@ -53,4 +59,4 @@
     protected nestedVisitor = (): ITypeVisitor<string> => {
-        return new TsArgumentTypeVisitor(this.knownTypes, this.currType, false);
+        return new TsArgumentTypeVisitor(this.knownTypes, this.currType, false, this.typeGenerationFlags);
     };
 }

src/commands/generate/tsReturnTypeVisitor.ts

@@ -30,3 +30,4 @@ /**
 } from "conjure-api";
-import { createHashableTypeName } from "./utils";
+import { ITypeGenerationFlags } from "./typeGenerationFlags";
+import { createHashableTypeName, isFlavorizable } from "./utils";
 
@@ -38,2 +39,3 @@ export class TsReturnTypeVisitor implements ITypeVisitor<string> {
         protected isTopLevelBinary: boolean,
+        protected typeGenerationFlags: ITypeGenerationFlags,
     ) {}
@@ -69,4 +71,11 @@
             const keyTypeDefinition = this.knownTypes.get(createHashableTypeName(obj.keyType.reference));
-            if (keyTypeDefinition != null && ITypeDefinition.isEnum(keyTypeDefinition)) {
-                return `{ [key in ${obj.keyType.reference.name}]?: ${valueTsType} }`;
+            if (keyTypeDefinition != null) {
+                if (ITypeDefinition.isEnum(keyTypeDefinition)) {
+                    return `{ [key in ${obj.keyType.reference.name}]?: ${valueTsType} }`;
+                } else if (
+                    ITypeDefinition.isAlias(keyTypeDefinition) &&
+                    isFlavorizable(keyTypeDefinition.alias.alias, this.typeGenerationFlags.flavorizedAliases)
+                ) {
+                    return `{ [key: I${obj.keyType.reference.name}]: ${valueTsType} }`;
+                }
             }
@@ -92,3 +101,6 @@ }
             throw new Error(`unknown reference type. package: '${obj.package}', name: '${obj.name}'`);
-        } else if (ITypeDefinition.isAlias(typeDefinition)) {
+        } else if (
+            ITypeDefinition.isAlias(typeDefinition) &&
+            !isFlavorizable(typeDefinition.alias.alias, this.typeGenerationFlags.flavorizedAliases)
+        ) {
             return IType.visit(typeDefinition.alias.alias, this);
@@ -114,4 +126,4 @@ } else if (ITypeDefinition.isEnum(typeDefinition)) {
     protected nestedVisitor = (): ITypeVisitor<string> => {
-        return new TsReturnTypeVisitor(this.knownTypes, this.currType, false);
+        return new TsReturnTypeVisitor(this.knownTypes, this.currType, false, this.typeGenerationFlags);
     };
 }

src/commands/generate/typeGenerator.ts

@@ -17,4 +17,11 @@ /**
  */
-import { IEnumDefinition, IObjectDefinition, IType, ITypeDefinition, IUnionDefinition } from "conjure-api";
 import {
+    IAliasDefinition,
+    IEnumDefinition,
+    IObjectDefinition,
+    IType,
+    ITypeDefinition,
+    IUnionDefinition,
+} from "conjure-api";
+import {
     FunctionDeclarationStructure,
@@ -30,3 +37,4 @@ ImportDeclarationStructure,
 import { TsReturnTypeVisitor } from "./tsReturnTypeVisitor";
-import { addDeprecatedToDocs, doubleQuote, isValidFunctionName, singleQuote } from "./utils";
+import { ITypeGenerationFlags } from "./typeGenerationFlags";
+import { addDeprecatedToDocs, doubleQuote, isFlavorizable, isValidFunctionName, singleQuote } from "./utils";
 
@@ -37,12 +45,12 @@ export function generateType(
     simpleAst: SimpleAst,
+    typeGenerationFlags: ITypeGenerationFlags,
 ): Promise<void> {
     if (ITypeDefinition.isAlias(definition)) {
-        // TODO(gracew): implement at some point
-        return Promise.resolve();
+        return generateAlias(definition.alias, knownTypes, simpleAst, typeGenerationFlags);
     } else if (ITypeDefinition.isEnum(definition)) {
         return generateEnum(definition.enum, simpleAst);
     } else if (ITypeDefinition.isObject(definition)) {
-        return generateObject(definition.object, knownTypes, simpleAst);
+        return generateObject(definition.object, knownTypes, simpleAst, typeGenerationFlags);
     } else if (ITypeDefinition.isUnion(definition)) {
-        return generateUnion(definition.union, knownTypes, simpleAst);
+        return generateUnion(definition.union, knownTypes, simpleAst, typeGenerationFlags);
     } else {
@@ -53,5 +61,45 @@ throw Error("unsupported type: " + definition);
 
+const FLAVOR_TYPE_FIELD = "__conjure_type";
+const FLAVOR_PACKAGE_FIELD = "__conjure_package";
+
 /**
  * Generates a file of the following format:
  * ```
+ *  export type ExampleAlias = string & {
+ *     __conjure_type?: "ExampleAlias";
+ *     __conjure_package?: "com.palantir.product";
+ *  };
+ * ```
+ */
+export async function generateAlias(
+    definition: IAliasDefinition,
+    knownTypes: Map<string, ITypeDefinition>,
+    simpleAst: SimpleAst,
+    typeGenerationFlags: ITypeGenerationFlags,
+): Promise<void> {
+    if (isFlavorizable(definition.alias, typeGenerationFlags.flavorizedAliases)) {
+        const tsTypeVisitor = new TsReturnTypeVisitor(knownTypes, definition.typeName, false, typeGenerationFlags);
+        const fieldType = IType.visit(definition.alias, tsTypeVisitor);
+        const sourceFile = simpleAst.createSourceFile(definition.typeName);
+        const typeAlias = sourceFile.addTypeAlias({
+            isExported: true,
+            name: "I" + definition.typeName.name,
+            type: [
+                `${fieldType} & {`,
+                `\t${FLAVOR_TYPE_FIELD}?: "${definition.typeName.name}",`,
+                `\t${FLAVOR_PACKAGE_FIELD}?: "${definition.typeName.package}",`,
+                "}",
+            ].join("\n"),
+        });
+        if (definition.docs) {
+            typeAlias.addJsDoc(definition.docs);
+        }
+        sourceFile.formatText();
+        return sourceFile.save();
+    }
+}
+
+/**
+ * Generates a file of the following format:
+ * ```
  * export namespace EnumExample {
@@ -142,5 +190,6 @@ *     export type ONE = "ONE";
     simpleAst: SimpleAst,
+    typeGenerationFlags: ITypeGenerationFlags,
 ) {
-    const tsTypeVisitor = new TsReturnTypeVisitor(knownTypes, definition.typeName, false);
-    const importsVisitor = new ImportsVisitor(knownTypes, definition.typeName);
+    const tsTypeVisitor = new TsReturnTypeVisitor(knownTypes, definition.typeName, false, typeGenerationFlags);
+    const importsVisitor = new ImportsVisitor(knownTypes, definition.typeName, typeGenerationFlags);
     const properties: PropertySignatureStructure[] = [];
@@ -189,5 +238,6 @@ const imports: ImportDeclarationStructure[] = [];
     simpleAst: SimpleAst,
+    typeGenerationFlags: ITypeGenerationFlags,
 ) {
     const unionTsType = "I" + definition.typeName.name;
-    const unionSourceFileInput = processUnionMembers(unionTsType, definition, knownTypes);
+    const unionSourceFileInput = processUnionMembers(unionTsType, definition, knownTypes, typeGenerationFlags);
 
@@ -258,5 +308,6 @@ const sourceFile = simpleAst.createSourceFile(definition.typeName);
     knownTypes: Map<string, ITypeDefinition>,
+    typeGenerationFlags: ITypeGenerationFlags,
 ) {
-    const tsTypeVisitor = new TsReturnTypeVisitor(knownTypes, definition.typeName, false);
-    const importsVisitor = new ImportsVisitor(knownTypes, definition.typeName);
+    const tsTypeVisitor = new TsReturnTypeVisitor(knownTypes, definition.typeName, false, typeGenerationFlags);
+    const importsVisitor = new ImportsVisitor(knownTypes, definition.typeName, typeGenerationFlags);
 
@@ -263,0 +314,0 @@ const imports: ImportDeclarationStructure[] = [];

src/commands/generate/utils.ts

@@ -17,3 +17,10 @@ /**
  */
-import { IEndpointDefinition, IEnumValueDefinition, IFieldDefinition, ITypeName } from "conjure-api";
+import {
+    IEndpointDefinition,
+    IEnumValueDefinition,
+    IFieldDefinition,
+    IType,
+    ITypeName,
+    PrimitiveType,
+} from "conjure-api";
 
@@ -125,1 +132,12 @@ export const CONJURE_CLIENT = "conjure-client";
 }
+
+const NON_FLAVORIZABLE_TYPES = new Set<PrimitiveType>([
+    PrimitiveType.ANY,
+    PrimitiveType.BOOLEAN,
+    PrimitiveType.BINARY,
+    PrimitiveType.DATETIME,
+]);
+
+export function isFlavorizable(type: IType, flavorizedAliases: boolean): boolean {
+    return flavorizedAliases && IType.isPrimitive(type) && !NON_FLAVORIZABLE_TYPES.has(type.primitive);
+}

No alert changes

Improved metrics

Total package byte prevSize

262579

increased by6.36%

Number of package files

85

increased by4.94%

Lines of code

4566

increased by7.01%

No dependency changes