@goast/kotlin 0.4.13 → 0.4.14-beta1

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

@@ -1,117 +0,0 @@
-
-import fs from 'fs-extra';
-
-import {
-  type ApiService,
-  type AppendValueGroup,
-  appendValueGroup,
-  Factory,
-  type MaybePromise,
-  type OpenApiGeneratorContext,
-  OpenApiServicesGenerationProviderBase,
-} from '@goast/core';
-
-import { kt } from '../../../ast/index.js';
-import { KotlinFileBuilder } from '../../../file-builder.js';
-import {
-  defaultKotlinServicesGeneratorConfig,
-  type KotlinServiceGeneratorOutput,
-  type KotlinServicesGeneratorConfig,
-  type KotlinServicesGeneratorContext,
-  type KotlinServicesGeneratorInput,
-  type KotlinServicesGeneratorOutput,
-} from './models.js';
-import { getReferenceFactories } from './refs.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');
-    const providerContext = this.getProviderContext(context, config, defaultKotlinServicesGeneratorConfig);
-    return Object.assign(providerContext, {
-      refs: getReferenceFactories(providerContext.config),
-    });
-  }
-
-  protected override generateAdditionalFiles(ctx: KotlinServicesGeneratorContext): void {
-    this.generateApiExceptionHandler(ctx);
-  }
-
-  protected generateApiExceptionHandler(ctx: Context): void {
-    const packageName = ctx.refs.apiExceptionHandler.packageName ?? ctx.config.packageName;
-    const dir = `${ctx.config.outputDir}/${packageName.replace(/\./g, '/')}`;
-    const fileName = `${ctx.refs.apiExceptionHandler.refName}.kt`;
-    console.log(`Generating Api Exception Handler to ${fileName}...`);
-
-    const builder = new KotlinFileBuilder(packageName, ctx.config);
-    builder.append(this.getApiExceptionHandlerInterface(ctx));
-    fs.writeFileSync(`${dir}/${fileName}`, builder.toString());
-  }
-
-  protected getApiExceptionHandlerFileContent(ctx: Context): AppendValueGroup<KotlinFileBuilder> {
-    return appendValueGroup([this.getApiExceptionHandlerInterface(ctx)], '\n');
-  }
-
-  protected getApiExceptionHandlerInterface(ctx: Context): kt.Interface<KotlinFileBuilder> {
-    return kt.interface(ctx.refs.apiExceptionHandler.refName, {
-      members: [
-        kt.function('handleApiException', {
-          doc: kt.doc('Handler for API exceptions.', [kt.docTag('return', 'Response entity.')]),
-          suspend: true,
-          parameters: [
-            kt.parameter('exception', kt.refs.throwable(), {
-              description: 'Exception that has been thrown by the API.',
-            }),
-          ],
-          returnType: kt.refs.spring.responseEntity(['*']),
-        }),
-      ],
-    });
-  }
-}

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

@@ -1,116 +0,0 @@
-import "../_dnt.test_polyfills.js";
-import { EOL } from 'node:os';
-
-import { expect } from '../deps/jsr.io/@std/expect/1.0.13/expect.js';
-import { describe, it } from '../deps/jsr.io/@std/testing/1.0.9/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

@@ -1,98 +0,0 @@
-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

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

package/src/src/utils.ts

@@ -1,39 +0,0 @@
-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

@@ -1,63 +0,0 @@
-import "../_dnt.test_polyfills.js";
-import { join } from 'node:path';
-
-import { afterEach, describe, test } from '../deps/jsr.io/@std/testing/1.0.9/bdd.js';
-import { restore, stub } from '../deps/jsr.io/@std/testing/1.0.9/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

@@ -1,227 +0,0 @@
-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();