@seamapi/nextlove-sdk-generator 1.4.0

package/LICENSE.txt

@@ -0,0 +1,20 @@
+The MIT License (MIT)
+
+Copyright (c) 2021-2023 Seam Labs, Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/README.md

@@ -0,0 +1,16 @@
+# Nextlove SDK Generator
+
+> This SDK generator is currently configured to only work with Seam Connect,
+> output is also committed directly to the repo for ease of inspection and
+> testing
+
+This automatically generates an SDK based on the Seam Connect OpenAPI config.
+
+## Usage
+
+```bash
+npm install
+npm run generate:python-sdk
+npm run generate:ruby-sdk
+# output is in "./output/python" and "./output/ruby"
+```

package/index.d.ts

@@ -0,0 +1,6 @@
+export * from "./lib/types.js";
+export * from "./lib/index.js";
+export * from "./lib/generate-csharp-sdk/generate-csharp-sdk.js";
+export * from "./lib/generate-python-sdk/index.js";
+export * from "./lib/generate-ruby-sdk/index.js";
+export * from "./lib/generate-php-sdk/index.js";

package/index.js

@@ -0,0 +1,7 @@
+export * from "./lib/types.js";
+export * from "./lib/index.js";
+export * from "./lib/generate-csharp-sdk/generate-csharp-sdk.js";
+export * from "./lib/generate-python-sdk/index.js";
+export * from "./lib/generate-ruby-sdk/index.js";
+export * from "./lib/generate-php-sdk/index.js";
+//# sourceMappingURL=index.js.map

package/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["src/index.ts"],"names":[],"mappings":"AAAA,cAAc,gBAAgB,CAAA;AAC9B,cAAc,gBAAgB,CAAA;AAC9B,cAAc,kDAAkD,CAAA;AAChE,cAAc,oCAAoC,CAAA;AAClD,cAAc,kCAAkC,CAAA;AAChD,cAAc,iCAAiC,CAAA"}

package/lib/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/lib/cli.js

@@ -0,0 +1,53 @@
+#!/usr/bin/env node
+import yargs from "yargs/yargs";
+import * as path from "path";
+import * as fs from "fs";
+import { generatePythonSDK, generateCSharpSDK, generateRubySDK, writeFs, generatePhpSDK, } from "@seamapi/nextlove-sdk-generator";
+// Define the command structure
+yargs(process.argv.slice(2)).command("generate [language] [outputDir]", "Generate SDK", (yargs) => {
+    return yargs
+        .positional("language", {
+        describe: "The language to generate SDK for",
+        type: "string",
+        choices: ["python", "ruby", "csharp", "php"],
+    })
+        .positional("outputDir", {
+        describe: "The directory to output generated SDK",
+        type: "string",
+    });
+}, (argv) => {
+    if (typeof argv.language === "string" &&
+        typeof argv.outputDir === "string") {
+        generateSDK(argv.language, argv.outputDir);
+    }
+}).argv;
+// Define the generateSDK function
+async function generateSDK(language, outputDir) {
+    // Resolve the output directory path
+    const outputPath = path.resolve(outputDir);
+    // Create the output directory if it doesn't exist
+    if (!fs.existsSync(outputPath)) {
+        fs.mkdirSync(outputPath, { recursive: true });
+    }
+    let filesystem = {};
+    // Generate SDK based on the specified language
+    switch (language) {
+        case "python":
+            filesystem = await generatePythonSDK();
+            break;
+        case "ruby":
+            filesystem = await generateRubySDK();
+            break;
+        case "csharp":
+            filesystem = await generateCSharpSDK();
+            break;
+        case "php":
+            filesystem = await generatePhpSDK();
+            break;
+        default:
+            console.error(`Unsupported language: ${language}`);
+            process.exit(1);
+    }
+    writeFs(outputPath, filesystem);
+}
+//# sourceMappingURL=cli.js.map

package/lib/cli.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli.js","sourceRoot":"","sources":["../src/lib/cli.ts"],"names":[],"mappings":";AAEA,OAAO,KAAK,MAAM,aAAa,CAAA;AAC/B,OAAO,KAAK,IAAI,MAAM,MAAM,CAAA;AAC5B,OAAO,KAAK,EAAE,MAAM,IAAI,CAAA;AACxB,OAAO,EACL,iBAAiB,EACjB,iBAAiB,EACjB,eAAe,EACf,OAAO,EACP,cAAc,GACf,MAAM,iCAAiC,CAAA;AAExC,+BAA+B;AAC/B,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,OAAO,CAClC,iCAAiC,EACjC,cAAc,EACd,CAAC,KAAK,EAAE,EAAE;IACR,OAAO,KAAK;SACT,UAAU,CAAC,UAAU,EAAE;QACtB,QAAQ,EAAE,kCAAkC;QAC5C,IAAI,EAAE,QAAQ;QACd,OAAO,EAAE,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,KAAK,CAAC;KAC7C,CAAC;SACD,UAAU,CAAC,WAAW,EAAE;QACvB,QAAQ,EAAE,uCAAuC;QACjD,IAAI,EAAE,QAAQ;KACf,CAAC,CAAA;AACN,CAAC,EACD,CAAC,IAAI,EAAE,EAAE;IACP,IACE,OAAO,IAAI,CAAC,QAAQ,KAAK,QAAQ;QACjC,OAAO,IAAI,CAAC,SAAS,KAAK,QAAQ,EAClC;QACA,WAAW,CAAC,IAAI,CAAC,QAAQ,EAAE,IAAI,CAAC,SAAS,CAAC,CAAA;KAC3C;AACH,CAAC,CACF,CAAC,IAAI,CAAA;AAEN,kCAAkC;AAClC,KAAK,UAAU,WAAW,CAAC,QAAgB,EAAE,SAAiB;IAC5D,oCAAoC;IACpC,MAAM,UAAU,GAAG,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,CAAA;IAE1C,kDAAkD;IAClD,IAAI,CAAC,EAAE,CAAC,UAAU,CAAC,UAAU,CAAC,EAAE;QAC9B,EAAE,CAAC,SAAS,CAAC,UAAU,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAA;KAC9C;IAED,IAAI,UAAU,GAAG,EAAE,CAAA;IACnB,+CAA+C;IAC/C,QAAQ,QAAQ,EAAE;QAChB,KAAK,QAAQ;YACX,UAAU,GAAG,MAAM,iBAAiB,EAAE,CAAA;YACtC,MAAK;QACP,KAAK,MAAM;YACT,UAAU,GAAG,MAAM,eAAe,EAAE,CAAA;YACpC,MAAK;QACP,KAAK,QAAQ;YACX,UAAU,GAAG,MAAM,iBAAiB,EAAE,CAAA;YACtC,MAAK;QACP,KAAK,KAAK;YACR,UAAU,GAAG,MAAM,cAAc,EAAE,CAAA;YACnC,MAAK;QACP;YACE,OAAO,CAAC,KAAK,CAAC,yBAAyB,QAAQ,EAAE,CAAC,CAAA;YAClD,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAA;KAClB;IAED,OAAO,CAAC,UAAU,EAAE,UAAU,CAAC,CAAA;AACjC,CAAC"}

package/lib/fs-util/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./populate-fs.js";
+export * from "./write-fs.js";

package/lib/fs-util/index.js

@@ -0,0 +1,3 @@
+export * from "./populate-fs.js";
+export * from "./write-fs.js";
+//# sourceMappingURL=index.js.map

package/lib/fs-util/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/lib/fs-util/index.ts"],"names":[],"mappings":"AAAA,cAAc,kBAAkB,CAAA;AAChC,cAAc,eAAe,CAAA"}

package/lib/fs-util/populate-fs.d.ts

@@ -0,0 +1 @@
+export declare const populateFs: (dir: string, filesystem: Record<string, string>) => void;

package/lib/fs-util/populate-fs.js

@@ -0,0 +1,11 @@
+import path from "path";
+import fs from "fs";
+import { walkSync } from "@nodelib/fs.walk";
+export const populateFs = (dir, filesystem) => {
+    walkSync(dir).forEach(({ dirent, path: filePath }) => {
+        if (dirent.isDirectory())
+            return;
+        filesystem[path.relative(dir, filePath)] = fs.readFileSync(filePath, "utf-8");
+    });
+};
+//# sourceMappingURL=populate-fs.js.map

package/lib/fs-util/populate-fs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"populate-fs.js","sourceRoot":"","sources":["../../src/lib/fs-util/populate-fs.ts"],"names":[],"mappings":"AAAA,OAAO,IAAI,MAAM,MAAM,CAAA;AACvB,OAAO,EAAE,MAAM,IAAI,CAAA;AACnB,OAAO,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAA;AAE3C,MAAM,CAAC,MAAM,UAAU,GAAG,CAAC,GAAW,EAAE,UAAkC,EAAE,EAAE;IAC5E,QAAQ,CAAC,GAAG,CAAC,CAAC,OAAO,CAAC,CAAC,EAAE,MAAM,EAAE,IAAI,EAAE,QAAQ,EAAE,EAAE,EAAE;QACnD,IAAI,MAAM,CAAC,WAAW,EAAE;YAAE,OAAM;QAEhC,UAAU,CAAC,IAAI,CAAC,QAAQ,CAAC,GAAG,EAAE,QAAQ,CAAC,CAAC,GAAG,EAAE,CAAC,YAAY,CACxD,QAAQ,EACR,OAAO,CACR,CAAA;IACH,CAAC,CAAC,CAAA;AACJ,CAAC,CAAA"}

package/lib/fs-util/write-fs.d.ts

@@ -0,0 +1 @@
+export declare const writeFs: (dir: string, filesystem: Record<string, string>) => void;

package/lib/fs-util/write-fs.js

@@ -0,0 +1,10 @@
+import path from "path";
+import fs from "fs";
+export const writeFs = (dir, filesystem) => {
+    for (const [filepath, contents] of Object.entries(filesystem)) {
+        const fullPath = path.join(dir, filepath);
+        fs.mkdirSync(path.dirname(fullPath), { recursive: true });
+        fs.writeFileSync(fullPath, contents);
+    }
+};
+//# sourceMappingURL=write-fs.js.map

package/lib/fs-util/write-fs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"write-fs.js","sourceRoot":"","sources":["../../src/lib/fs-util/write-fs.ts"],"names":[],"mappings":"AAAA,OAAO,IAAI,MAAM,MAAM,CAAA;AACvB,OAAO,EAAE,MAAM,IAAI,CAAA;AAEnB,MAAM,CAAC,MAAM,OAAO,GAAG,CAAC,GAAW,EAAE,UAAkC,EAAE,EAAE;IACzE,KAAK,MAAM,CAAC,QAAQ,EAAE,QAAQ,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,UAAU,CAAC,EAAE;QAC7D,MAAM,QAAQ,GAAG,IAAI,CAAC,IAAI,CAAC,GAAG,EAAE,QAAQ,CAAC,CAAA;QACzC,EAAE,CAAC,SAAS,CAAC,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAA;QACzD,EAAE,CAAC,aAAa,CAAC,QAAQ,EAAE,QAAQ,CAAC,CAAA;KACrC;AACH,CAAC,CAAA"}

package/lib/generate-csharp-sdk/codegen.d.ts

@@ -0,0 +1,235 @@
+export type CSharpNamespace = string[];
+declare class CompilerCtx {
+    tabSize: number;
+    eol: string;
+    indent(): string;
+    withIndent(serialized: string): string;
+    combineWords(...words: (string | undefined)[]): string;
+    combineStatements(...statements: (string | undefined)[]): string;
+    combineNodes(...nodes: (CSharpNode | undefined)[]): string;
+    combineAdjacent(...nodes: (CSharpNode | undefined)[]): string;
+    serializeNamespace(namespace: CSharpNamespace): string;
+}
+declare abstract class CSharpNode {
+    abstract serialize(ctx: CompilerCtx): string;
+}
+declare abstract class Statement extends CSharpNode {
+    private includeSemicolon;
+    constructor(includeSemicolon: boolean);
+    serialize(ctx: CompilerCtx): string;
+    abstract serializeStatement(ctx: CompilerCtx): string;
+}
+declare class StatementBlock extends Statement {
+    statements: Statement[];
+    constructor(statements: Statement[]);
+    serializeStatement(ctx: CompilerCtx): string;
+}
+declare class CSharpFile extends Statement {
+    statements: StatementBlock[];
+    constructor(statements: StatementBlock[]);
+    serializeStatement(ctx: CompilerCtx): string;
+}
+declare class CurlyBlock extends Statement {
+    statements: StatementBlock[];
+    separator?: string | undefined;
+    constructor(statements: StatementBlock[], separator?: string | undefined);
+    serializeStatement(ctx: CompilerCtx): string;
+}
+declare class CurlyBlockWithNode<T extends CSharpNode> extends CurlyBlock {
+    declaration: T;
+    constructor(declaration: T, statements: StatementBlock[], separator?: string);
+    serialize(ctx: CompilerCtx): string;
+}
+declare class UsingStatement extends Statement {
+    namespace: CSharpNamespace;
+    constructor(namespace: CSharpNamespace);
+    serializeStatement(ctx: CompilerCtx): string;
+}
+declare class NamespaceNode extends CSharpNode {
+    namespace: CSharpNamespace;
+    constructor(namespace: CSharpNamespace);
+    serialize(ctx: CompilerCtx): string;
+}
+declare class VisibilityModifiers extends CSharpNode {
+    visibility: ("public" | "private" | "protected" | "internal" | "async" | "partial" | "virtual" | "override" | "abstract")[];
+    constructor(visibility: ("public" | "private" | "protected" | "internal" | "async" | "partial" | "virtual" | "override" | "abstract")[]);
+    serialize(_ctx: CompilerCtx): string;
+}
+declare class ClassDeclarationSpecifier extends CSharpNode {
+    name: TokenNode;
+    base?: string | undefined;
+    modifiers?: VisibilityModifiers | undefined;
+    classToken: TokenNode;
+    constructor(name: TokenNode, base?: string | undefined, modifiers?: VisibilityModifiers | undefined, classToken?: TokenNode);
+    serialize(ctx: CompilerCtx): string;
+}
+declare class EnumDeclarationSpecifier extends CSharpNode {
+    name: TokenNode;
+    modifiers?: VisibilityModifiers | undefined;
+    constructor(name: TokenNode, modifiers?: VisibilityModifiers | undefined);
+    serialize(ctx: CompilerCtx): string;
+}
+declare class Class extends CurlyBlockWithNode<ClassDeclarationSpecifier> {
+}
+declare class Enum extends CurlyBlockWithNode<EnumDeclarationSpecifier> {
+    declaration: EnumDeclarationSpecifier;
+    constructor(declaration: EnumDeclarationSpecifier, statements: StatementBlock[]);
+}
+declare class RawNode extends CSharpNode {
+    raw: string;
+    constructor(raw: string);
+    serialize(): string;
+}
+declare class CompositeNode extends CSharpNode {
+    nodes: CSharpNode[];
+    constructor(nodes: CSharpNode[]);
+    serialize(ctx: CompilerCtx): string;
+}
+declare class NodeStatement extends Statement {
+    node: CSharpNode;
+    constructor(node: CSharpNode, includeSemicolon?: boolean);
+    serializeStatement(ctx: CompilerCtx): string;
+}
+declare class RawStatement extends Statement {
+    raw: string;
+    constructor(raw: string, includeSemicolon?: boolean);
+    serializeStatement(): string;
+}
+declare class AnnotatedStatement<T extends Statement> extends Statement {
+    annotation: string;
+    annotated: T;
+    properties?: CSharpNode[] | undefined;
+    static getPropertyList(properties: Record<string, CSharpNode | undefined>): (TokenNode | AssignNode<TokenNode, CSharpNode>)[];
+    constructor(annotation: string, annotated: T, properties?: CSharpNode[] | undefined);
+    serializeStatement(ctx: CompilerCtx): string;
+}
+declare class Literal extends CSharpNode {
+    value: any;
+    constructor(value: any);
+    serialize(): string;
+}
+declare class TokenNode extends CSharpNode {
+    token: string;
+    static readonly TYPE_STRING: TokenNode;
+    static readonly TYPE_INT: TokenNode;
+    static readonly TYPE_FLOAT: TokenNode;
+    static readonly TYPE_BOOLEAN: TokenNode;
+    static readonly TYPE_OBJECT: TokenNode;
+    static readonly TYPE_OBJECT_CLASS: TokenNode;
+    static readonly TYPE_JOBJECT: TokenNode;
+    constructor(token: string, isReserved?: boolean);
+    serialize(_: CompilerCtx): string;
+}
+declare class TokenNodeGeneric extends TokenNode {
+    token: string;
+    generics: TypeNode[];
+    constructor(token: string, generics: TypeNode[]);
+    serialize(ctx: CompilerCtx): string;
+}
+declare class TypeArgumentsNode extends CSharpNode {
+    generics: TypeNode[];
+    constructor(generics: TypeNode[]);
+    serialize(ctx: CompilerCtx): string;
+}
+declare class TokenNodeApplyFunction extends CSharpNode {
+    token: CSharpNode;
+    args: CSharpNode[];
+    typeArguments?: TypeArgumentsNode | undefined;
+    constructor(token: CSharpNode, args: CSharpNode[], typeArguments?: TypeArgumentsNode | undefined);
+    serialize(ctx: CompilerCtx): string;
+}
+declare class ApplyConstructorNode extends TokenNodeApplyFunction {
+    token: TokenNode;
+    args: CSharpNode[];
+    typeArguments?: TypeArgumentsNode | undefined;
+    constructor(token: TokenNode, args: CSharpNode[], typeArguments?: TypeArgumentsNode | undefined);
+    serialize(ctx: CompilerCtx): string;
+}
+declare class ReturnStatement extends Statement {
+    value: CSharpNode;
+    constructor(value: CSharpNode);
+    serializeStatement(ctx: CompilerCtx): string;
+}
+declare class TypeNode extends CSharpNode {
+    type: CSharpNode;
+    nullable: boolean;
+    generics?: TypeArgumentsNode | undefined;
+    constructor(type: CSharpNode, nullable?: boolean, generics?: TypeArgumentsNode | undefined);
+    serialize(ctx: CompilerCtx): string;
+}
+declare class AccessChain extends CSharpNode {
+    nodes: CSharpNode[];
+    constructor(nodes: CSharpNode[]);
+    serialize(ctx: CompilerCtx): string;
+}
+declare abstract class AbstractFieldDeclaration<Token extends CSharpNode, Body extends Statement | undefined, Rhs extends CSharpNode = CSharpNode> extends Statement {
+    type: TypeNode | undefined;
+    token: Token;
+    body: Body;
+    visibility?: VisibilityModifiers | undefined;
+    rhs?: Rhs | undefined;
+    constructor(type: TypeNode | undefined, token: Token, body: Body, visibility?: VisibilityModifiers | undefined, rhs?: Rhs | undefined);
+    serializeStatement(ctx: CompilerCtx): string;
+}
+declare class FieldDeclaration extends AbstractFieldDeclaration<TokenNode, undefined> {
+}
+declare class ParameterNode extends CSharpNode {
+    type: TypeNode;
+    name: TokenNode;
+    defaultValue?: CSharpNode | undefined;
+    constructor(type: TypeNode, name: TokenNode, defaultValue?: CSharpNode | undefined);
+    serialize(ctx: CompilerCtx): string;
+}
+declare class MethodNode extends CSharpNode {
+    name: TokenNode;
+    parameters?: ParameterNode[] | undefined;
+    constructor(name: TokenNode, parameters?: ParameterNode[] | undefined);
+    serialize(ctx: CompilerCtx): string;
+}
+declare class MethodDeclaration extends AbstractFieldDeclaration<MethodNode, CurlyBlock | undefined> {
+}
+declare class PropertyMethods extends Statement {
+    get?: {
+        statements?: StatementBlock[];
+        visibility?: VisibilityModifiers;
+    } | undefined;
+    set?: {
+        statements?: StatementBlock[];
+        visibility?: VisibilityModifiers;
+    } | undefined;
+    constructor(get?: {
+        statements?: StatementBlock[];
+        visibility?: VisibilityModifiers;
+    } | undefined, set?: {
+        statements?: StatementBlock[];
+        visibility?: VisibilityModifiers;
+    } | undefined);
+    serializeStatement(ctx: CompilerCtx): string;
+}
+declare class PropertyDeclaration extends AbstractFieldDeclaration<TokenNode, PropertyMethods> {
+}
+declare class AssignNode<LHS extends CSharpNode, RHS extends CSharpNode> extends CSharpNode {
+    lhs: LHS;
+    rhs: RHS;
+    operation: "=";
+    constructor(lhs: LHS, rhs: RHS, operation?: "=");
+    serialize(ctx: CompilerCtx): string;
+}
+declare class AssignStatement<LHS extends CSharpNode, RHS extends CSharpNode> extends Statement {
+    lhs: LHS;
+    rhs: RHS;
+    operation: "=";
+    constructor(lhs: LHS, rhs: RHS, includeSemicolon?: boolean, operation?: "=");
+    serializeStatement(ctx: CompilerCtx): string;
+}
+declare class AwaitNode extends CompositeNode {
+    node: CSharpNode;
+    constructor(node: CSharpNode);
+}
+declare class ParanthesisNode extends CompositeNode {
+    node: CSharpNode;
+    constructor(node: CSharpNode);
+}
+declare class NamespaceBlock extends CurlyBlockWithNode<NamespaceNode> {
+}
+export { RawNode, RawStatement, CSharpFile, CurlyBlock, CurlyBlockWithNode, UsingStatement, ClassDeclarationSpecifier, Class, StatementBlock, AnnotatedStatement, Literal, VisibilityModifiers, CompilerCtx, FieldDeclaration, TokenNode, PropertyDeclaration, MethodDeclaration, MethodNode, TypeNode, PropertyMethods, TokenNodeGeneric, ParameterNode, AssignStatement, Statement, EnumDeclarationSpecifier, AssignNode, Enum, TokenNodeApplyFunction, TypeArgumentsNode, ReturnStatement, ApplyConstructorNode, AccessChain, CompositeNode, NamespaceBlock, NamespaceNode, AwaitNode, ParanthesisNode, CSharpNode, NodeStatement, };