Socket
Socket
Sign inDemoInstall

conjure-typescript

Package Overview
Dependencies
178
Maintainers
1
Versions
46
Alerts
File Explorer

Advanced tools

Install Socket

Detect and block malicious and high-risk dependencies

Install

Comparing version 5.3.0 to 5.4.0

lib/commands/generate/typeGenerationFlags.d.ts

3

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>;

@@ -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);

@@ -30,2 +30,6 @@ /**

productDependencies?: string;
/**
* Generates flavoured types for compatible aliases (string, rids...)
*/
flavorizedAliases?: boolean;
}

@@ -32,0 +36,0 @@ export interface ITsConfig {

@@ -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,

@@ -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>;

@@ -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)

@@ -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[];

@@ -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;

@@ -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>;

@@ -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 = [];

@@ -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>;
}

@@ -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;

@@ -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;

@@ -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 @@ }

@@ -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>;

@@ -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 = [];

@@ -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 {};
"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
{
"name": "conjure-typescript",
"version": "5.3.0",
"version": "5.4.0",
"description": "A conjure generator for Typescript",

@@ -5,0 +5,0 @@ "bin": {

@@ -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 @@

@@ -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;

@@ -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());

@@ -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) {

@@ -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 @@

@@ -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);
};
}

@@ -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);
};
}

@@ -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[] = [];

@@ -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);
}

Sorry, the diff of this file is not supported yet

Sorry, the diff of this file is not supported yet

Sorry, the diff of this file is not supported yet

Sorry, the diff of this file is not supported yet

Sorry, the diff of this file is not supported yet

Sorry, the diff of this file is not supported yet

Sorry, the diff of this file is not supported yet

Sorry, the diff of this file is not supported yet

Sorry, the diff of this file is not supported yet

SocketSocket SOC 2 Logo

Product

  • Package Alerts
  • Integrations
  • Docs
  • Pricing
  • FAQ
  • Roadmap

Stay in touch

Get open source security insights delivered straight into your inbox.


  • Terms
  • Privacy
  • Security

Made with ⚡️ by Socket Inc