initial commit of actions
This commit is contained in:
commit
949ece5785
44660 changed files with 12034344 additions and 0 deletions
448
github/codeql-action-v2/node_modules/twirp-ts/build/protoc-gen-twirp-ts/gen/twirp.js
generated
vendored
Normal file
448
github/codeql-action-v2/node_modules/twirp-ts/build/protoc-gen-twirp-ts/gen/twirp.js
generated
vendored
Normal file
|
|
@ -0,0 +1,448 @@
|
|||
"use strict";
|
||||
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
|
||||
function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
|
||||
return new (P || (P = Promise))(function (resolve, reject) {
|
||||
function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
|
||||
function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
|
||||
function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
|
||||
step((generator = generator.apply(thisArg, _arguments || [])).next());
|
||||
});
|
||||
};
|
||||
var __importDefault = (this && this.__importDefault) || function (mod) {
|
||||
return (mod && mod.__esModule) ? mod : { "default": mod };
|
||||
};
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
exports.generateTwirpServer = exports.generateTwirpClient = exports.generateTwirp = void 0;
|
||||
const ts_poet_1 = require("ts-poet");
|
||||
const camel_case_1 = require("camel-case");
|
||||
const local_type_name_1 = require("../local-type-name");
|
||||
const path_1 = __importDefault(require("path"));
|
||||
const TwirpServer = ts_poet_1.imp("TwirpServer@twirp-ts");
|
||||
const Interceptor = ts_poet_1.imp("Interceptor@twirp-ts");
|
||||
const RouterEvents = ts_poet_1.imp("RouterEvents@twirp-ts");
|
||||
const chainInterceptors = ts_poet_1.imp("chainInterceptors@twirp-ts");
|
||||
const TwirpContentType = ts_poet_1.imp("TwirpContentType@twirp-ts");
|
||||
const TwirpContext = ts_poet_1.imp("TwirpContext@twirp-ts");
|
||||
const TwirpError = ts_poet_1.imp("TwirpError@twirp-ts");
|
||||
const TwirpErrorCode = ts_poet_1.imp("TwirpErrorCode@twirp-ts");
|
||||
/**
|
||||
* Generates the client and server implementation of the twirp
|
||||
* specification.
|
||||
* @param ctx
|
||||
* @param file
|
||||
*/
|
||||
function generateTwirp(ctx, file) {
|
||||
return __awaiter(this, void 0, void 0, function* () {
|
||||
const contents = file.service.map((service) => {
|
||||
return ts_poet_1.joinCode([
|
||||
genClient(ctx, file, service),
|
||||
genServer(ctx, file, service),
|
||||
], { on: "\n\n" });
|
||||
});
|
||||
return ts_poet_1.joinCode(contents, { on: "\n\n" }).toStringWithImports();
|
||||
});
|
||||
}
|
||||
exports.generateTwirp = generateTwirp;
|
||||
/**
|
||||
* Generates the client implementation of the twirp specification.
|
||||
* @param ctx
|
||||
* @param file
|
||||
*/
|
||||
function generateTwirpClient(ctx, file) {
|
||||
return __awaiter(this, void 0, void 0, function* () {
|
||||
const contents = file.service.map((service) => {
|
||||
return ts_poet_1.joinCode([genClient(ctx, file, service)], { on: "\n\n" });
|
||||
});
|
||||
return ts_poet_1.joinCode(contents, { on: "\n\n" }).toStringWithImports();
|
||||
});
|
||||
}
|
||||
exports.generateTwirpClient = generateTwirpClient;
|
||||
/**
|
||||
* Generates the server implementation of the twirp specification.
|
||||
* @param ctx
|
||||
* @param file
|
||||
*/
|
||||
function generateTwirpServer(ctx, file) {
|
||||
return __awaiter(this, void 0, void 0, function* () {
|
||||
const contents = file.service.map((service) => {
|
||||
return ts_poet_1.joinCode([genServer(ctx, file, service)], { on: "\n\n" });
|
||||
});
|
||||
return ts_poet_1.joinCode(contents, { on: "\n\n" }).toStringWithImports();
|
||||
});
|
||||
}
|
||||
exports.generateTwirpServer = generateTwirpServer;
|
||||
function genClient(ctx, file, service) {
|
||||
return ts_poet_1.code `
|
||||
//==================================//
|
||||
// Client Code //
|
||||
//==================================//
|
||||
|
||||
interface Rpc {
|
||||
request(
|
||||
service: string,
|
||||
method: string,
|
||||
contentType: "application/json" | "application/protobuf",
|
||||
data: object | Uint8Array,
|
||||
): Promise<object | Uint8Array>;
|
||||
}
|
||||
|
||||
${genTwirpClientInterface(ctx, file, service)}
|
||||
|
||||
${genTwripClientJSONImpl(ctx, file, service)}
|
||||
${genTwripClientProtobufImpl(ctx, file, service)}
|
||||
`;
|
||||
}
|
||||
function genTwirpClientInterface(ctx, file, service) {
|
||||
const methods = service.method.map((method) => {
|
||||
return ts_poet_1.code `
|
||||
${formatMethodName(ctx, method.name)}(request: ${relativeMessageName(ctx, file, method.inputType)}): Promise<${relativeMessageName(ctx, file, method.outputType)}>
|
||||
`;
|
||||
});
|
||||
return ts_poet_1.code `
|
||||
export interface ${service.name}Client {
|
||||
${ts_poet_1.joinCode(methods, { on: "\n" })}
|
||||
}
|
||||
`;
|
||||
}
|
||||
/**
|
||||
* Generates the json client
|
||||
* @param ctx
|
||||
* @param file
|
||||
* @param service
|
||||
*/
|
||||
function genTwripClientJSONImpl(ctx, file, service) {
|
||||
const methods = service.method.map((method) => {
|
||||
return ts_poet_1.code `
|
||||
${formatMethodName(ctx, method.name)}(request: ${relativeMessageName(ctx, file, method.inputType)}): Promise<${relativeMessageName(ctx, file, method.outputType)}> {
|
||||
const data = ${relativeMessageName(ctx, file, method.inputType)}.${encodeJSON(ctx, "request")};
|
||||
const promise = this.rpc.request(
|
||||
"${file.package ? file.package + "." : ""}${service.name}",
|
||||
"${formatMethodName(ctx, method.name)}",
|
||||
"application/json",
|
||||
data as object,
|
||||
);
|
||||
return promise.then((data) => ${relativeMessageName(ctx, file, method.outputType)}.${decodeJSON(ctx, "data as any")});
|
||||
}
|
||||
`;
|
||||
});
|
||||
const bindings = service.method.map((method) => {
|
||||
return ts_poet_1.code `
|
||||
this.${formatMethodName(ctx, method.name)}.bind(this);
|
||||
`;
|
||||
});
|
||||
return ts_poet_1.code `
|
||||
export class ${service.name}ClientJSON implements ${service.name}Client {
|
||||
private readonly rpc: Rpc;
|
||||
constructor(rpc: Rpc) {
|
||||
this.rpc = rpc;
|
||||
${ts_poet_1.joinCode(bindings, { on: `\n` })}
|
||||
}
|
||||
${ts_poet_1.joinCode(methods, { on: `\n\n` })}
|
||||
}
|
||||
`;
|
||||
}
|
||||
/**
|
||||
* Generate the protobuf client
|
||||
* @param ctx
|
||||
* @param file
|
||||
* @param service
|
||||
*/
|
||||
function genTwripClientProtobufImpl(ctx, file, service) {
|
||||
const methods = service.method.map((method) => {
|
||||
return ts_poet_1.code `
|
||||
${formatMethodName(ctx, method.name)}(request: ${relativeMessageName(ctx, file, method.inputType)}): Promise<${relativeMessageName(ctx, file, method.outputType)}> {
|
||||
const data = ${relativeMessageName(ctx, file, method.inputType)}.${encodeProtobuf(ctx, "request")};
|
||||
const promise = this.rpc.request(
|
||||
"${file.package ? file.package + "." : ""}${service.name}",
|
||||
"${formatMethodName(ctx, method.name)}",
|
||||
"application/protobuf",
|
||||
data,
|
||||
);
|
||||
return promise.then((data) => ${relativeMessageName(ctx, file, method.outputType)}.${decodeProtobuf(ctx, "data as Uint8Array")});
|
||||
}
|
||||
`;
|
||||
});
|
||||
const bindings = service.method.map((method) => {
|
||||
return ts_poet_1.code `
|
||||
this.${formatMethodName(ctx, method.name)}.bind(this);
|
||||
`;
|
||||
});
|
||||
return ts_poet_1.code `
|
||||
export class ${service.name}ClientProtobuf implements ${service.name}Client {
|
||||
private readonly rpc: Rpc;
|
||||
constructor(rpc: Rpc) {
|
||||
this.rpc = rpc;
|
||||
${ts_poet_1.joinCode(bindings, { on: `\n` })}
|
||||
}
|
||||
${ts_poet_1.joinCode(methods, { on: `\n\n` })}
|
||||
}
|
||||
`;
|
||||
}
|
||||
/**
|
||||
* Generates twirp service definition
|
||||
* @param ctx
|
||||
* @param file
|
||||
* @param service
|
||||
*/
|
||||
function genTwirpService(ctx, file, service) {
|
||||
const importService = service.name;
|
||||
const serverMethods = service.method.map((method) => {
|
||||
return ts_poet_1.code `
|
||||
${formatMethodName(ctx, method.name)}(ctx: T, request: ${relativeMessageName(ctx, file, method.inputType)}): Promise<${relativeMessageName(ctx, file, method.outputType)}>
|
||||
`;
|
||||
});
|
||||
const methodEnum = service.method.map((method) => {
|
||||
return ts_poet_1.code `${formatMethodName(ctx, method.name)} = "${formatMethodName(ctx, method.name)}",`;
|
||||
});
|
||||
const methodList = service.method.map((method) => {
|
||||
return ts_poet_1.code `${importService}Method.${formatMethodName(ctx, method.name)}`;
|
||||
});
|
||||
return ts_poet_1.code `
|
||||
export interface ${importService}Twirp<T extends ${TwirpContext} = ${TwirpContext}> {
|
||||
${ts_poet_1.joinCode(serverMethods, { on: `\n` })}
|
||||
}
|
||||
|
||||
export enum ${importService}Method {
|
||||
${ts_poet_1.joinCode(methodEnum, { on: "\n" })}
|
||||
}
|
||||
|
||||
export const ${importService}MethodList = [${ts_poet_1.joinCode(methodList, { on: "," })}];
|
||||
`;
|
||||
}
|
||||
/**
|
||||
* Generates the twirp server specification
|
||||
* @param ctx
|
||||
* @param file
|
||||
* @param service
|
||||
*/
|
||||
function genServer(ctx, file, service) {
|
||||
var _a;
|
||||
const importService = service.name;
|
||||
return ts_poet_1.code `
|
||||
|
||||
//==================================//
|
||||
// Server Code //
|
||||
//==================================//
|
||||
|
||||
${genTwirpService(ctx, file, service)}
|
||||
|
||||
export function create${importService}Server<T extends ${TwirpContext} = ${TwirpContext}>(service: ${importService}Twirp<T>) {
|
||||
return new ${TwirpServer}<${importService}Twirp, T>({
|
||||
service,
|
||||
packageName: "${(_a = file.package) !== null && _a !== void 0 ? _a : ''}",
|
||||
serviceName: "${importService}",
|
||||
methodList: ${importService}MethodList,
|
||||
matchRoute: match${importService}Route,
|
||||
})
|
||||
}
|
||||
${genRouteHandler(ctx, file, service)}
|
||||
${ts_poet_1.joinCode(genHandleRequestMethod(ctx, file, service), { on: "\n\n" })}
|
||||
${ts_poet_1.joinCode(genHandleJSONRequest(ctx, file, service), { on: "\n\n" })}
|
||||
${ts_poet_1.joinCode(genHandleProtobufRequest(ctx, file, service), { on: "\n\n" })}
|
||||
`;
|
||||
}
|
||||
/**
|
||||
* Generate the route handler
|
||||
* @param ctx
|
||||
* @param file
|
||||
* @param service
|
||||
*/
|
||||
function genRouteHandler(ctx, file, service) {
|
||||
const cases = service.method.map(method => ts_poet_1.code `
|
||||
case "${formatMethodName(ctx, method.name)}":
|
||||
return async (ctx: T, service: ${service.name}Twirp ,data: Buffer, interceptors?: ${Interceptor}<T, ${relativeMessageName(ctx, file, method.inputType)}, ${relativeMessageName(ctx, file, method.outputType)}>[]) => {
|
||||
ctx = {...ctx, methodName: "${formatMethodName(ctx, method.name)}" }
|
||||
await events.onMatch(ctx);
|
||||
return handle${formatMethodName(ctx, method.name, service.name)}Request(ctx, service, data, interceptors)
|
||||
}
|
||||
`);
|
||||
return ts_poet_1.code `
|
||||
function match${service.name}Route<T extends ${TwirpContext} = ${TwirpContext}>(method: string, events: ${RouterEvents}<T>) {
|
||||
switch(method) {
|
||||
${ts_poet_1.joinCode(cases, { on: `\n` })}
|
||||
default:
|
||||
events.onNotFound();
|
||||
const msg = \`no handler found\`;
|
||||
throw new ${TwirpError}(${TwirpErrorCode}.BadRoute, msg)
|
||||
}
|
||||
}
|
||||
`;
|
||||
}
|
||||
/**
|
||||
* Generate request handler for methods
|
||||
* @param ctx
|
||||
* @param file
|
||||
* @param service
|
||||
*/
|
||||
function genHandleRequestMethod(ctx, file, service) {
|
||||
return service.method.map(method => {
|
||||
return ts_poet_1.code `
|
||||
function handle${formatMethodName(ctx, method.name, service.name)}Request<T extends ${TwirpContext} = ${TwirpContext}>(ctx: T, service: ${service.name}Twirp ,data: Buffer, interceptors?: ${Interceptor}<T, ${relativeMessageName(ctx, file, method.inputType)}, ${relativeMessageName(ctx, file, method.outputType)}>[]): Promise<string | Uint8Array> {
|
||||
switch (ctx.contentType) {
|
||||
case ${TwirpContentType}.JSON:
|
||||
return handle${formatMethodName(ctx, method.name, service.name)}JSON<T>(ctx, service, data, interceptors);
|
||||
case ${TwirpContentType}.Protobuf:
|
||||
return handle${formatMethodName(ctx, method.name, service.name)}Protobuf<T>(ctx, service, data, interceptors);
|
||||
default:
|
||||
const msg = "unexpected Content-Type";
|
||||
throw new ${TwirpError}(${TwirpErrorCode}.BadRoute, msg);
|
||||
}
|
||||
}
|
||||
`;
|
||||
});
|
||||
}
|
||||
/**
|
||||
* Generate a JSON request handler for a method
|
||||
* @param ctx
|
||||
* @param file
|
||||
* @param service
|
||||
*/
|
||||
function genHandleJSONRequest(ctx, file, service) {
|
||||
return service.method.map(method => {
|
||||
return ts_poet_1.code `
|
||||
|
||||
async function handle${formatMethodName(ctx, method.name, service.name)}JSON<T extends ${TwirpContext} = ${TwirpContext}>(ctx: T, service: ${service.name}Twirp, data: Buffer, interceptors?: ${Interceptor}<T, ${relativeMessageName(ctx, file, method.inputType)}, ${relativeMessageName(ctx, file, method.outputType)}>[]) {
|
||||
let request: ${relativeMessageName(ctx, file, method.inputType)}
|
||||
let response: ${relativeMessageName(ctx, file, method.outputType)}
|
||||
|
||||
try {
|
||||
const body = JSON.parse(data.toString() || "{}");
|
||||
request = ${relativeMessageName(ctx, file, method.inputType)}.${decodeJSON(ctx, "body")};
|
||||
} catch(e) {
|
||||
if (e instanceof Error) {
|
||||
const msg = "the json request could not be decoded";
|
||||
throw new ${TwirpError}(${TwirpErrorCode}.Malformed, msg).withCause(e, true);
|
||||
}
|
||||
}
|
||||
|
||||
if (interceptors && interceptors.length > 0) {
|
||||
const interceptor = ${chainInterceptors}(...interceptors) as Interceptor<T, ${relativeMessageName(ctx, file, method.inputType)}, ${relativeMessageName(ctx, file, method.outputType)}>
|
||||
response = await interceptor(ctx, request!, (ctx, inputReq) => {
|
||||
return service.${formatMethodName(ctx, method.name)}(ctx, inputReq);
|
||||
});
|
||||
} else {
|
||||
response = await service.${formatMethodName(ctx, method.name)}(ctx, request!)
|
||||
}
|
||||
|
||||
return JSON.stringify(${relativeMessageName(ctx, file, method.outputType)}.${encodeJSON(ctx, "response")} as string);
|
||||
}
|
||||
`;
|
||||
});
|
||||
}
|
||||
/**
|
||||
* Generates a protobuf request handler
|
||||
* @param ctx
|
||||
* @param file
|
||||
* @param service
|
||||
*/
|
||||
function genHandleProtobufRequest(ctx, file, service) {
|
||||
return service.method.map(method => {
|
||||
return ts_poet_1.code `
|
||||
|
||||
async function handle${formatMethodName(ctx, method.name, service.name)}Protobuf<T extends ${TwirpContext} = ${TwirpContext}>(ctx: T, service: ${service.name}Twirp, data: Buffer, interceptors?: ${Interceptor}<T, ${relativeMessageName(ctx, file, method.inputType)}, ${relativeMessageName(ctx, file, method.outputType)}>[]) {
|
||||
let request: ${relativeMessageName(ctx, file, method.inputType)}
|
||||
let response: ${relativeMessageName(ctx, file, method.outputType)}
|
||||
|
||||
try {
|
||||
request = ${relativeMessageName(ctx, file, method.inputType)}.${decodeProtobuf(ctx, "data")};
|
||||
} catch(e) {
|
||||
if (e instanceof Error) {
|
||||
const msg = "the protobuf request could not be decoded";
|
||||
throw new ${TwirpError}(${TwirpErrorCode}.Malformed, msg).withCause(e, true);
|
||||
}
|
||||
}
|
||||
|
||||
if (interceptors && interceptors.length > 0) {
|
||||
const interceptor = ${chainInterceptors}(...interceptors) as Interceptor<T, ${relativeMessageName(ctx, file, method.inputType)}, ${relativeMessageName(ctx, file, method.outputType)}>
|
||||
response = await interceptor(ctx, request!, (ctx, inputReq) => {
|
||||
return service.${formatMethodName(ctx, method.name)}(ctx, inputReq);
|
||||
});
|
||||
} else {
|
||||
response = await service.${formatMethodName(ctx, method.name)}(ctx, request!)
|
||||
}
|
||||
|
||||
return Buffer.from(${relativeMessageName(ctx, file, method.outputType)}.${encodeProtobuf(ctx, "response")});
|
||||
}
|
||||
`;
|
||||
});
|
||||
}
|
||||
var SupportedLibs;
|
||||
(function (SupportedLibs) {
|
||||
SupportedLibs["TSProto"] = "ts-proto";
|
||||
SupportedLibs["ProtobufTS"] = "protobuf-ts";
|
||||
})(SupportedLibs || (SupportedLibs = {}));
|
||||
function validateLib(lib) {
|
||||
switch (lib) {
|
||||
case "ts-proto":
|
||||
return SupportedLibs.TSProto;
|
||||
case "protobuf-ts":
|
||||
return SupportedLibs.ProtobufTS;
|
||||
default:
|
||||
throw new Error(`library ${lib} not supported`);
|
||||
}
|
||||
}
|
||||
function decodeJSON(ctx, dataName) {
|
||||
const protoLib = validateLib(ctx.lib);
|
||||
if (protoLib === SupportedLibs.TSProto) {
|
||||
return ts_poet_1.code `fromJSON(${dataName})`;
|
||||
}
|
||||
return ts_poet_1.code `fromJson(${dataName}, { ignoreUnknownFields: true })`;
|
||||
}
|
||||
function encodeJSON(ctx, dataName) {
|
||||
const protoLib = validateLib(ctx.lib);
|
||||
if (protoLib === SupportedLibs.TSProto) {
|
||||
return ts_poet_1.code `toJSON(${dataName})`;
|
||||
}
|
||||
return ts_poet_1.code `toJson(${dataName}, {useProtoFieldName: true, emitDefaultValues: ${ctx.emitDefaultValues ? 'true' : 'false'}})`;
|
||||
}
|
||||
function encodeProtobuf(ctx, dataName) {
|
||||
const protoLib = validateLib(ctx.lib);
|
||||
if (protoLib === SupportedLibs.TSProto) {
|
||||
return ts_poet_1.code `encode(${dataName}).finish()`;
|
||||
}
|
||||
return ts_poet_1.code `toBinary(${dataName})`;
|
||||
}
|
||||
function decodeProtobuf(ctx, dataName) {
|
||||
const protoLib = validateLib(ctx.lib);
|
||||
if (protoLib === SupportedLibs.TSProto) {
|
||||
return ts_poet_1.code `decode(${dataName})`;
|
||||
}
|
||||
return ts_poet_1.code `fromBinary(${dataName})`;
|
||||
}
|
||||
function relativeMessageName(ctx, file, messageName) {
|
||||
const registry = ctx.registry;
|
||||
const symbols = ctx.symbols;
|
||||
const entry = symbols.find(registry.resolveTypeName(messageName));
|
||||
if (!entry) {
|
||||
throw new Error(`Message ${messageName} not found`);
|
||||
}
|
||||
const messageType = local_type_name_1.createLocalTypeName(entry.descriptor, registry);
|
||||
const relativePath = createRelativeImportPath(file.name, entry.file.getFilename());
|
||||
return ts_poet_1.code `${ts_poet_1.imp(`${messageType}@${relativePath}`)}`;
|
||||
}
|
||||
/**
|
||||
* Create a relative path for an import statement like
|
||||
* `import {Foo} from "./foo"`
|
||||
*/
|
||||
function createRelativeImportPath(currentPath, pathToImportFrom) {
|
||||
// create relative path to the file to import
|
||||
let fromPath = path_1.default.relative(path_1.default.dirname(currentPath), pathToImportFrom);
|
||||
// on windows, this may add backslash directory separators.
|
||||
// we replace them with forward slash.
|
||||
if (path_1.default.sep !== "/") {
|
||||
fromPath = fromPath.split(path_1.default.sep).join("/");
|
||||
}
|
||||
// drop file extension
|
||||
fromPath = fromPath.replace(/\.[a-z]+$/, '');
|
||||
// make sure to start with './' to signal relative path to module resolution
|
||||
if (!fromPath.startsWith('../') && !fromPath.startsWith('./')) {
|
||||
fromPath = './' + fromPath;
|
||||
}
|
||||
return fromPath;
|
||||
}
|
||||
function formatMethodName(ctx, methodName, serviceName) {
|
||||
if (methodName === undefined)
|
||||
return undefined;
|
||||
serviceName = serviceName || "";
|
||||
return ctx.camelCase ? camel_case_1.camelCase(serviceName) + camel_case_1.camelCase(methodName) : serviceName + methodName;
|
||||
}
|
||||
Loading…
Add table
Add a link
Reference in a new issue