@goast/kotlin 0.4.7-beta2 → 0.4.7

package/src/src/generators/services/spring-controllers/spring-controllers-generator.ts

@@ -0,0 +1,70 @@
+import {
+  type ApiService,
+  Factory,
+  type MaybePromise,
+  type OpenApiGeneratorContext,
+  OpenApiServicesGenerationProviderBase,
+} from '@goast/core';
+
+import {
+  defaultKotlinServicesGeneratorConfig,
+  type KotlinServiceGeneratorOutput,
+  type KotlinServicesGeneratorConfig,
+  type KotlinServicesGeneratorContext,
+  type KotlinServicesGeneratorInput,
+  type KotlinServicesGeneratorOutput,
+} from './models.js';
+import {
+  DefaultKotlinSpringControllerGenerator,
+  type KotlinSpringControllerGenerator,
+} from './spring-controller-generator.js';
+
+type Input = KotlinServicesGeneratorInput;
+type Output = KotlinServicesGeneratorOutput;
+type Config = KotlinServicesGeneratorConfig;
+type ServiceOutput = KotlinServiceGeneratorOutput;
+type Context = KotlinServicesGeneratorContext;
+
+export class KotlinSpringControllersGenerator extends OpenApiServicesGenerationProviderBase<
+  Input,
+  Output,
+  Config,
+  ServiceOutput,
+  Context
+> {
+  private readonly _serviceGeneratorFactory: Factory<KotlinSpringControllerGenerator, []>;
+
+  constructor(serviceGeneratorFactory?: Factory<KotlinSpringControllerGenerator, []>) {
+    super();
+    this._serviceGeneratorFactory = serviceGeneratorFactory ??
+      Factory.fromValue(new DefaultKotlinSpringControllerGenerator());
+  }
+
+  protected initResult(): Output {
+    return {
+      kotlin: {
+        services: {},
+      },
+    };
+  }
+
+  protected generateService(ctx: Context, service: ApiService): MaybePromise<ServiceOutput> {
+    const serviceGenerator = this._serviceGeneratorFactory.create();
+    return serviceGenerator.generate({
+      ...ctx,
+      service,
+    });
+  }
+
+  protected addServiceResult(ctx: Context, service: ApiService, result: ServiceOutput): void {
+    ctx.output.kotlin.services[service.id] = result;
+  }
+
+  protected buildContext(
+    context: OpenApiGeneratorContext<KotlinServicesGeneratorInput>,
+    config?: Partial<Config> | undefined,
+  ): Context {
+    context.data.services = context.data.services.filter((x) => x.name !== 'exclude-from-generation');
+    return this.getProviderContext(context, config, defaultKotlinServicesGeneratorConfig);
+  }
+}

package/src/src/import-collection.test.ts

@@ -0,0 +1,116 @@
+import "../_dnt.test_polyfills.js";
+import { EOL } from 'node:os';
+
+import { expect } from '../deps/jsr.io/@std/expect/1.0.9/expect.js';
+import { describe, it } from '../deps/jsr.io/@std/testing/1.0.6/bdd.js';
+
+import { StringBuilder } from '@goast/core';
+
+import { ImportCollection } from './import-collection.js';
+
+describe('ImportCollection', () => {
+  describe('hasImport', () => {
+    it('should return false when no imports are added', () => {
+      const importCollection = new ImportCollection();
+      expect(importCollection.hasImports).toBe(false);
+    });
+
+    it('should return true when imports are added', () => {
+      const importCollection = new ImportCollection();
+      importCollection.addImport('SomeClass', 'some.package');
+      expect(importCollection.hasImports).toBe(true);
+    });
+  });
+
+  describe('imports', () => {
+    it('should return an empty array when no imports are added', () => {
+      const importCollection = new ImportCollection();
+      expect(importCollection.imports).toEqual([]);
+    });
+
+    it('should return an array of imports when imports are added', () => {
+      const importCollection = new ImportCollection();
+      importCollection.addImport('SomeClass', 'some.package');
+      importCollection.addImport('AnotherClass', 'another.package');
+      expect(importCollection.imports).toEqual([
+        { packageName: 'some.package', typeName: 'SomeClass' },
+        { packageName: 'another.package', typeName: 'AnotherClass' },
+      ]);
+    });
+  });
+
+  describe('addImport', () => {
+    it('should add an import to the collection', () => {
+      const importCollection = new ImportCollection();
+      importCollection.addImport('SomeClass', 'some.package');
+      expect(importCollection.imports).toEqual([{ packageName: 'some.package', typeName: 'SomeClass' }]);
+    });
+
+    it('should add an import to the collection using an object', () => {
+      const importCollection = new ImportCollection();
+      importCollection.addImport({ packageName: 'some.package', typeName: 'SomeClass' });
+      expect(importCollection.imports).toEqual([{ packageName: 'some.package', typeName: 'SomeClass' }]);
+    });
+  });
+
+  describe('addImports', () => {
+    it('should add multiple imports to the collection', () => {
+      const importCollection = new ImportCollection();
+      importCollection.addImports([
+        { packageName: 'some.package', typeName: 'SomeClass' },
+        { packageName: 'another.package', typeName: 'AnotherClass' },
+      ]);
+      expect(importCollection.imports).toEqual([
+        { packageName: 'some.package', typeName: 'SomeClass' },
+        { packageName: 'another.package', typeName: 'AnotherClass' },
+      ]);
+    });
+  });
+
+  describe('clear', () => {
+    it('should clear all imports', () => {
+      const importCollection = new ImportCollection();
+      importCollection.addImport('SomeClass', 'some.package');
+      importCollection.clear();
+      expect(importCollection.imports).toEqual([]);
+    });
+  });
+
+  describe('toString', () => {
+    it('should return an empty string when no imports are added', () => {
+      const importCollection = new ImportCollection();
+      expect(importCollection.toString()).toBe('');
+    });
+
+    it('should return a string of imports when imports are added', () => {
+      const importCollection = new ImportCollection();
+      importCollection.addImport('SomeClass', 'some.package');
+      importCollection.addImport('AnotherClass', 'another.package');
+      expect(importCollection.toString()).toBe(
+        `import another.package.AnotherClass${EOL}import some.package.SomeClass${EOL}`,
+      );
+    });
+  });
+
+  describe('writeTo', () => {
+    it('should write imports to a StringBuilder', () => {
+      const importCollection = new ImportCollection();
+      importCollection.addImport('SomeClass', 'some.package');
+      importCollection.addImport('AnotherClass', 'another.package');
+      const builder = new StringBuilder();
+      importCollection.writeTo(builder);
+      expect(builder.toString()).toBe(`import another.package.AnotherClass${EOL}import some.package.SomeClass${EOL}`);
+    });
+  });
+
+  it('should ignore global imports', () => {
+    const importCollection = new ImportCollection({
+      globalImports: ['kotlin.*', 'myPackage.MyClass'],
+    });
+    importCollection.addImport('String', 'kotlin');
+    importCollection.addImport('Int', 'kotlin');
+    importCollection.addImport('MyClass', 'myPackage');
+    importCollection.addImport('MyOtherClass', 'myPackage');
+    expect(importCollection.toString()).toBe(`import myPackage.MyOtherClass${EOL}`);
+  });
+});

package/src/src/import-collection.ts

@@ -0,0 +1,98 @@
+import { type SourceBuilderOptions, StringBuilder } from '@goast/core';
+
+import type { KotlinImport } from './common-results.js';
+import { defaultKotlinGeneratorConfig } from './config.js';
+
+export type ImportCollectionOptions = {
+  globalImports: string[];
+};
+
+export const defaultImportCollectionOptions: ImportCollectionOptions = {
+  globalImports: defaultKotlinGeneratorConfig.globalImports,
+};
+
+export class ImportCollection {
+  private readonly _imports: Map<string, Set<string>> = new Map();
+  private readonly _options: ImportCollectionOptions;
+
+  constructor(options: Partial<ImportCollectionOptions> = {}) {
+    this._options = { ...defaultImportCollectionOptions, ...options };
+  }
+
+  public get hasImports(): boolean {
+    return this._imports.size > 0;
+  }
+
+  public get imports(): KotlinImport[] {
+    return Array.from(this._imports.entries())
+      .map(([fromPackage, importNames]) =>
+        Array.from(importNames).map((importName) => ({
+          packageName: fromPackage,
+          typeName: importName,
+        }))
+      )
+      .flat();
+  }
+
+  public addImport(importName: string, fromModule: string): void;
+  public addImport(importObj: KotlinImport): void;
+  public addImport(importOrImportName: KotlinImport | string, fromModule?: string): void {
+    const importName = typeof importOrImportName === 'string' ? importOrImportName : importOrImportName.typeName;
+    fromModule = typeof importOrImportName === 'string' ? fromModule : importOrImportName.packageName;
+
+    if (!fromModule) {
+      return;
+    }
+
+    const existingImport = this._imports.get(fromModule);
+    if (existingImport) {
+      existingImport.add(importName);
+    } else {
+      this._imports.set(fromModule!, new Set([importName]));
+    }
+  }
+
+  public addImports(imports: KotlinImport[]): void {
+    for (const importObj of imports) {
+      this.addImport(importObj);
+    }
+  }
+
+  public clear(): void {
+    this._imports.clear();
+  }
+
+  public toString(options?: Partial<SourceBuilderOptions>): string {
+    const builder = new StringBuilder(options);
+    this.writeTo(builder);
+    return builder.toString();
+  }
+
+  public writeTo(builder: StringBuilder) {
+    if (this._imports.size > 0) {
+      const globalPackages = this._options.globalImports
+        .filter((g) => g.endsWith('.*'))
+        .map((g) => g.substring(0, g.length - 2));
+      const globalImports = this._options.globalImports.filter((g) => !g.endsWith('.*'));
+
+      Array.from(this._imports.entries())
+        .filter(([packageName]) => !globalPackages.includes(packageName))
+        .flatMap(([packageName, importNames]) => Array.from(importNames).map((importName) => [packageName, importName]))
+        .map(([packageName, importName]) => `${packageName}.${importName}`)
+        .filter((importPath) => !globalImports.includes(importPath))
+        .sort((a, b) => {
+          if (isCoreImport(a) && !isCoreImport(b)) {
+            return 1;
+          } else if (!isCoreImport(a) && isCoreImport(b)) {
+            return -1;
+          }
+          return a.localeCompare(b);
+        })
+        .forEach((importPath) => builder.appendLine(`import ${importPath}`));
+    }
+  }
+}
+
+function isCoreImport(importPath: string): boolean {
+  return importPath.startsWith('kotlin.') || importPath.startsWith('java.') || importPath.startsWith('javax.');
+}

package/src/src/types.ts

@@ -0,0 +1,3 @@
+import type { ApiParameter } from '@goast/core';
+
+export type ApiParameterWithMultipartInfo = ApiParameter & { multipart?: { name: string; isFile: boolean } };

package/src/src/utils.ts

@@ -0,0 +1,39 @@
+import type { Nullable } from '@goast/core';
+
+export function toKotlinStringLiteral(value: Nullable<string>): string {
+  if (!value) {
+    return '""';
+  }
+
+  const escaped = value
+    .replace(/(["\\$])/g, '\\$1')
+    .replace(/\n/g, '\\n')
+    .replace(/\r/g, '\\r')
+    .replace(/\t/g, '\\t');
+  return `"${escaped}"`;
+}
+
+export function toKotlinPropertyName(value: string): string {
+  if (value.match(/^[a-zA-Z_$][a-zA-Z_$0-9]*$/)) {
+    return value;
+  }
+  return `\`${value}\``;
+}
+
+export function modifyString<TArgs extends unknown[]>(
+  value: string,
+  modifier: string | RegExp | ((value: string, ...args: TArgs) => string) | undefined,
+  ...args: TArgs
+): string {
+  if (typeof modifier === 'string') {
+    return modifier;
+  }
+  if (modifier instanceof RegExp) {
+    const match = value.match(modifier);
+    return match?.[0] ?? value;
+  }
+  if (typeof modifier === 'function') {
+    return modifier(value, ...args);
+  }
+  return value;
+}

package/src/tests/openapi-models.test.ts

@@ -0,0 +1,63 @@
+import "../_dnt.test_polyfills.js";
+import { join } from 'node:path';
+
+import { afterEach, describe, test } from '../deps/jsr.io/@std/testing/1.0.6/bdd.js';
+import { restore, stub } from '../deps/jsr.io/@std/testing/1.0.6/mock.js';
+
+import fs from 'fs-extra';
+
+import { OpenApiGenerator, toCustomCase } from '@goast/core';
+import {
+  MultipartData,
+  openApiV2FilesDir,
+  openApiV3_1FilesDir,
+  openApiV3FilesDir,
+  type OpenApiVersion,
+  verify,
+} from '@goast/test-utils';
+
+import { KotlinModelsGenerator } from '../src/generators/models/models-generator.js';
+
+const filePaths: { [P in OpenApiVersion]: string } = {
+  '2.0': openApiV2FilesDir,
+  '3.0': openApiV3FilesDir,
+  '3.1': openApiV3_1FilesDir,
+};
+
+const testFilesAllVersions: string[] = ['simple-schemas.yml', 'detailed-schemas.yml', 'object-schemas.yml'];
+const testFilesV3x: string[] = ['oneof-schemas.yml', 'discriminated-schemas.yml'];
+
+for (const [version, path] of Object.entries(filePaths)) {
+  describe(`OpenAPI V${version}`, () => {
+    afterEach(() => {
+      restore();
+    });
+
+    const testFiles = version.startsWith('3') ? testFilesAllVersions.concat(testFilesV3x) : testFilesAllVersions;
+    for (const file of testFiles) {
+      const fileWithoutExt = file.replace(/\.[^/.]+$/, '');
+      test(toCustomCase(fileWithoutExt, { wordCasing: 'all-lower', wordSeparator: ' ' }), async (t) => {
+        const filePath = join(path, file);
+
+        const result = new MultipartData();
+        stub(fs, 'ensureDirSync');
+        stub(fs, 'writeFileSync', (path: fs.PathOrFileDescriptor, data: string | NodeJS.ArrayBufferView) => {
+          result.push([path.toString(), data.toString()]);
+        });
+
+        const generatorOptions = {
+          outputDir: 'out',
+          newLine: '\n',
+        };
+        const state = await new OpenApiGenerator(generatorOptions)
+          // deno-lint-ignore no-explicit-any
+          .useType(KotlinModelsGenerator, { __test__: true } as any)
+          .parseAndGenerate(filePath);
+        result.splice(0, 0, ['state', state]);
+
+        restore();
+        await verify(t, result);
+      });
+    }
+  });
+}

package/test_runner.js

@@ -0,0 +1,227 @@
+const pc = require("picocolors");
+const process = require("process");
+const { pathToFileURL } = require("url");
+const { testDefinitions } = require("@deno/shim-deno-test");
+const filePaths = [
+    "src/ast/nodes/annotation.test.js",
+    "src/ast/nodes/argument.test.js",
+    "src/ast/nodes/call.test.js",
+    "src/ast/nodes/class.test.js",
+    "src/ast/nodes/constructor.test.js",
+    "src/ast/nodes/doc-tag.test.js",
+    "src/ast/nodes/doc.test.js",
+    "src/ast/nodes/enum-value.test.js",
+    "src/ast/nodes/enum.test.js",
+    "src/ast/nodes/function.test.js",
+    "src/ast/nodes/generic-parameter.test.js",
+    "src/ast/nodes/init-block.test.js",
+    "src/ast/nodes/interface.test.js",
+    "src/ast/nodes/object.test.js",
+    "src/ast/nodes/parameter.test.js",
+    "src/ast/nodes/property.test.js",
+    "src/ast/nodes/reference.test.js",
+    "src/ast/nodes/string.test.js",
+    "src/import-collection.test.js",
+    "tests/openapi-models.test.js",
+];
+async function main() {
+    const testContext = {
+        process,
+        pc,
+    };
+    for (const [i, filePath] of filePaths.entries()) {
+        if (i > 0) {
+            console.log("");
+        }
+        const scriptPath = "./script/" + filePath;
+        console.log("Running tests in " + pc.underline(scriptPath) + "...\n");
+        process.chdir(__dirname + "/script");
+        const scriptTestContext = {
+            origin: pathToFileURL(filePath).toString(),
+            ...testContext,
+        };
+        try {
+            require(scriptPath);
+        }
+        catch (err) {
+            console.error(err);
+            process.exit(1);
+        }
+        await runTestDefinitions(testDefinitions.splice(0, testDefinitions.length), scriptTestContext);
+        const esmPath = "./esm/" + filePath;
+        console.log("\nRunning tests in " + pc.underline(esmPath) + "...\n");
+        process.chdir(__dirname + "/esm");
+        const esmTestContext = {
+            origin: pathToFileURL(filePath).toString(),
+            ...testContext,
+        };
+        await import(esmPath);
+        await runTestDefinitions(testDefinitions.splice(0, testDefinitions.length), esmTestContext);
+    }
+}
+async function runTestDefinitions(testDefinitions, options) {
+    var _a, _b;
+    const testFailures = [];
+    const hasOnly = testDefinitions.some((d) => d.only);
+    if (hasOnly) {
+        testDefinitions = testDefinitions.filter((d) => d.only);
+    }
+    for (const definition of testDefinitions) {
+        options.process.stdout.write("test " + definition.name + " ...");
+        if (definition.ignore) {
+            options.process.stdout.write(` ${options.pc.gray("ignored")}\n`);
+            continue;
+        }
+        const context = getTestContext(definition, undefined);
+        let pass = false;
+        try {
+            await definition.fn(context);
+            if (context.hasFailingChild) {
+                testFailures.push({
+                    name: definition.name,
+                    err: new Error("Had failing test step.")
+                });
+            }
+            else {
+                pass = true;
+            }
+        }
+        catch (err) {
+            testFailures.push({
+                name: definition.name,
+                err
+            });
+        }
+        const testStepOutput = context.getOutput();
+        if (testStepOutput.length > 0) {
+            options.process.stdout.write(testStepOutput);
+        }
+        else {
+            options.process.stdout.write(" ");
+        }
+        options.process.stdout.write(getStatusText(pass ? "ok" : "fail"));
+        options.process.stdout.write("\n");
+    }
+    if (testFailures.length > 0) {
+        options.process.stdout.write("\nFAILURES");
+        for (const failure of testFailures) {
+            options.process.stdout.write("\n\n");
+            options.process.stdout.write(failure.name + "\n");
+            options.process.stdout.write(indentText(((_b = (_a = failure.err) === null || _a === void 0 ? void 0 : _a.stack) !== null && _b !== void 0 ? _b : failure.err).toString(), 1));
+        }
+        options.process.exit(1);
+    }
+    else if (hasOnly) {
+        options.process.stdout.write('error: Test failed because the "only" option was used.\n');
+        options.process.exit(1);
+    }
+    function getTestContext(definition, parent) {
+        return {
+            name: definition.name,
+            parent,
+            origin: options.origin,
+            /** @type {any} */ err: undefined,
+            status: "ok",
+            children: [],
+            get hasFailingChild() {
+                return this.children.some((c) => c.status === "fail" || c.status === "pending");
+            },
+            getOutput() {
+                var _a;
+                let output = "";
+                if (this.parent) {
+                    output += "test " + this.name + " ...";
+                }
+                if (this.children.length > 0) {
+                    output += "\n" + this.children.map((c) => indentText(c.getOutput(), 1)).join("\n") + "\n";
+                }
+                else if (!this.err) {
+                    output += " ";
+                }
+                if (this.parent && this.err) {
+                    output += "\n";
+                }
+                if (this.err) {
+                    output += indentText(((_a = this.err.stack) !== null && _a !== void 0 ? _a : this.err).toString(), 1);
+                    if (this.parent) {
+                        output += "\n";
+                    }
+                }
+                if (this.parent) {
+                    output += getStatusText(this.status);
+                }
+                return output;
+            },
+            async step(nameOrTestDefinition, fn) {
+                const definition = getDefinition();
+                const context = getTestContext(definition, this);
+                context.status = "pending";
+                this.children.push(context);
+                if (definition.ignore) {
+                    context.status = "ignored";
+                    return false;
+                }
+                try {
+                    await definition.fn(context);
+                    context.status = "ok";
+                    if (context.hasFailingChild) {
+                        context.status = "fail";
+                        return false;
+                    }
+                    return true;
+                }
+                catch (err) {
+                    context.status = "fail";
+                    context.err = err;
+                    return false;
+                }
+                /** @returns {TestDefinition} */ function getDefinition() {
+                    if (typeof nameOrTestDefinition === "string") {
+                        if (!(fn instanceof Function)) {
+                            throw new TypeError("Expected function for second argument.");
+                        }
+                        return {
+                            name: nameOrTestDefinition,
+                            fn
+                        };
+                    }
+                    else if (typeof nameOrTestDefinition === "object") {
+                        return nameOrTestDefinition;
+                    }
+                    else {
+                        throw new TypeError("Expected a test definition or name and function.");
+                    }
+                }
+            }
+        };
+    }
+    function getStatusText(status) {
+        switch (status) {
+            case "ok":
+                return options.pc.green(status);
+            case "fail":
+            case "pending":
+                return options.pc.red(status);
+            case "ignored":
+                return options.pc.gray(status);
+            default:
+                {
+                    const _assertNever = status;
+                    return status;
+                }
+        }
+    }
+    function indentText(text, indentLevel) {
+        if (text === undefined) {
+            text = "[undefined]";
+        }
+        else if (text === null) {
+            text = "[null]";
+        }
+        else {
+            text = text.toString();
+        }
+        return text.split(/\r?\n/).map((line) => "  ".repeat(indentLevel) + line).join("\n");
+    }
+}
+main();