org.openapitools.codegen.languages.KtormSchemaCodegen Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of openapi-generator Show documentation
There is a newer version: 7.9.0
/*
 * Copyright 2018 OpenAPI-Generator Contributors (https://openapi-generator.tech)
 *
 * 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
 *
 *     https://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.
 */

package org.openapitools.codegen.languages;

import org.openapitools.codegen.*;
import org.openapitools.codegen.meta.features.*;
import org.openapitools.codegen.meta.GeneratorMetadata;
import org.openapitools.codegen.meta.Stability;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import org.apache.commons.lang3.StringUtils;

import java.util.*;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.io.File;

import io.swagger.v3.oas.models.media.IntegerSchema;
import io.swagger.v3.parser.util.SchemaTypeUtil;

import static org.openapitools.codegen.utils.StringUtils.*;

// This code was almost entirely based on MySqlSchemaCodegen.

@SuppressWarnings("unchecked")
public class KtormSchemaCodegen extends AbstractKotlinCodegen {
    static Logger LOGGER = LoggerFactory.getLogger(KtormSchemaCodegen.class);

    public static final String VENDOR_EXTENSION_SCHEMA = "x-ktorm-schema";
    public static final String DEFAULT_DATABASE_NAME = "defaultDatabaseName";
    public static final String IMPORT_MODEL_PACKAGE_NAME = "importModelPackageName";
    public static final String IDENTIFIER_NAMING_CONVENTION = "identifierNamingConvention";
    public static final String PRIMARY_KEY_CONVENTION = "primaryKeyConvention";
    public static final String ADD_SURROGATE_KEY = "addSurrogateKey";
    public static final Integer IDENTIFIER_MAX_LENGTH = 255;

    protected String importModelPackageName = "";
    protected String defaultDatabaseName = "sqlite.db";
    protected String databaseNamePrefix = "_", databaseNameSuffix = "";
    protected String tableNamePrefix = "_", tableNameSuffix = "";
    protected String columnNamePrefix = "_", columnNameSuffix = "";
    protected String identifierNamingConvention = "original";
    protected String primaryKeyConvention = "id";
    protected boolean addSurrogateKey = false;

    protected Map sqlTypeMapping = new HashMap();

    // https://ktorm.liuwj.me/api-docs/me.liuwj.ktorm.schema/index.html
    protected class SqlType {
        protected static final String Blob = "blob";
        protected static final String Boolean = "boolean";
        protected static final String Bytes = "bytes";
        protected static final String Date = "date";
        protected static final String DateTime = "datetime";
        protected static final String Decimal = "decimal";
        protected static final String Double = "double";
        protected static final String Float = "float";
        protected static final String Enum = "enum";
        protected static final String Int = "int";
        protected static final String Long = "long";
        protected static final String Text = "text";
        protected static final String Varchar = "varchar";
        protected static final String Json = "json";
    }

    public KtormSchemaCodegen() {
        super();

        generatorMetadata = GeneratorMetadata.newBuilder(generatorMetadata)
                .stability(Stability.BETA)
                .build();

        modifyFeatureSet(features -> features
                .includeDocumentationFeatures(DocumentationFeature.Readme)
                .wireFormatFeatures(EnumSet.noneOf(WireFormatFeature.class))
                .securityFeatures(EnumSet.noneOf(SecurityFeature.class))
                .excludeGlobalFeatures(
                        GlobalFeature.XMLStructureDefinitions,
                        GlobalFeature.Callbacks,
                        GlobalFeature.LinkObjects,
                        GlobalFeature.ParameterStyling
                )
                .excludeSchemaSupportFeatures(
                        SchemaSupportFeature.Polymorphism
                )
                .clientModificationFeatures(EnumSet.noneOf(ClientModificationFeature.class))
        );

        // http://www.sqlite.org/draft/tokenreq.html
        // https://sqlite.org/src/file/src/parse.y
        setReservedWordsLowerCase(
                Arrays.asList(
                        // SQL reserved words
                        "ABORT", "ACTION", "ADD", "AFTER", "ALL", "ALTER", "ALWAYS",
                        "ANALYZE", "AND", "ANY", "AS", "ASC", "ATTACH", "AUTOINCR",
                        "AUTOINCREMENT", "BEFORE", "BEGIN", "BETWEEN", "BITAND", "BITNOT",
                        "BITOR", "BLOB", "BY", "CASCADE", "CASE", "CAST", "CHECK",
                        "COLLATE", "COLUMN", "COMMA", "COMMIT", "CONCAT", "CONFLICT",
                        "CONSTRAINT", "CREATE", "CROSS", "CURRENT", "CURRENT_DATE",
                        "CURRENT_TIME", "CURRENT_TIMESTAMP", "DATABASE", "DEFAULT",
                        "DEFERRABLE", "DEFERRED", "DELETE", "DESC", "DETACH", "DISTINCT",
                        "DO", "DOT", "DROP", "EACH", "ELSE", "END", "EQ", "ESCAPE",
                        "EXCEPT", "EXCLUDE", "EXCLUSIVE", "EXISTS", "EXPLAIN", "FAIL",
                        "FILTER", "FIRST", "FLOAT", "FOLLOWING", "FOR", "FOREIGN", "FROM",
                        "FULL", "GE", "GENERATED", "GLOB", "GROUP", "GROUPS", "GT",
                        "HAVING", "ID", "IF", "IGNORE", "IMMEDIATE", "IN", "INDEX",
                        "INDEXED", "INITIALLY", "INNER", "INSERT", "INSTEAD", "INTEGER",
                        "INTERSECT", "INTO", "IS", "ISNULL", "JOIN", "KEY", "LAST", "LE",
                        "LEFT", "LIKE", "LIMIT", "LP", "LSHIFT", "LT", "MATCH", "MINUS",
                        "NATURAL", "NE", "NO", "NOT", "NOTHING", "NOTNULL", "NULL", "NULLS",
                        "OF", "OFFSET", "ON", "OR", "ORDER", "OTHERS", "OUTER", "OVER",
                        "PARTITION", "PLAN", "PLUS", "PRAGMA", "PRECEDING", "PRIMARY",
                        "QUERY", "RAISE", "RANGE", "RECURSIVE", "REFERENCES", "REGEXP",
                        "REINDEX", "RELEASE", "REM", "RENAME", "REPLACE", "RESTRICT",
                        "RIGHT", "ROLLBACK", "ROW", "ROWS", "RP", "RSHIFT", "SAVEPOINT",
                        "SELECT", "SET", "SLASH", "STAR", "STRING", "TABLE", "TEMP",
                        "TEMPORARY", "THEN", "TIES", "TO", "TRANSACTION", "TRIGGER",
                        "UNBOUNDED", "UNION", "UNIQUE", "UPDATE", "USING", "VACUUM",
                        "VALUES", "VARIABLE", "VIEW", "VIRTUAL", "WHEN", "WHERE",
                        "WINDOW", "WITH", "WITHOUT"
                )
        );

        typeMapping = new HashMap();
        typeMapping.put("string", "kotlin.String");
        typeMapping.put("boolean", "kotlin.Boolean");
        typeMapping.put("integer", "kotlin.Int");
        typeMapping.put("float", "kotlin.Float");
        typeMapping.put("long", "kotlin.Long");
        typeMapping.put("double", "kotlin.Double");
        typeMapping.put("ByteArray", "kotlin.ByteArray");
        typeMapping.put("number", "java.math.BigDecimal");
        typeMapping.put("date-time", "java.time.LocalDateTime");
        typeMapping.put("date", "java.time.LocalDate");
        typeMapping.put("file", "java.io.File");
        typeMapping.put("array", "kotlin.Array");
        typeMapping.put("list", "kotlin.collections.List");
        typeMapping.put("set", "kotlin.collections.Set");
        typeMapping.put("map", "kotlin.collections.Map");
        typeMapping.put("object", "kotlin.Any");
        typeMapping.put("binary", "kotlin.ByteArray");
        typeMapping.put("Date", "java.time.LocalDate");
        typeMapping.put("DateTime", "java.time.LocalDateTime");
        //missing on baseclass
        typeMapping.put("byte", "kotlin.Byte");
        typeMapping.put("short", "kotlin.Short");
        typeMapping.put("char", "kotlin.String");
        typeMapping.put("real", "kotlin.Double");
        typeMapping.put("UUID", "java.util.UUID"); //be explict
        typeMapping.put("URI", "java.net.URI"); //be explict
        typeMapping.put("decimal", "java.math.BigDecimal");
        typeMapping.put("BigDecimal", "java.math.BigDecimal");
        typeMapping.put("AnyType", "kotlin.Any");
        typeMapping.put("password", "kotlin.String"); //nice to have

        //mappings between kotlin and ktor
        // ref: https://ktorm.liuwj.me/en/schema-definition.html
        sqlTypeMapping.put("kotlin.String", SqlType.Text);
        sqlTypeMapping.put("kotlin.Boolean", SqlType.Boolean);
        sqlTypeMapping.put("kotlin.Byte", SqlType.Int);
        sqlTypeMapping.put("kotlin.Short", SqlType.Int);
        sqlTypeMapping.put("kotlin.Int", SqlType.Int);
        sqlTypeMapping.put("kotlin.Long", SqlType.Long);
        sqlTypeMapping.put("kotlin.Float", SqlType.Float);
        sqlTypeMapping.put("kotlin.Double", SqlType.Double);
        sqlTypeMapping.put("kotlin.ByteArray", SqlType.Blob);
        sqlTypeMapping.put("kotlin.Array", SqlType.Blob);
        sqlTypeMapping.put("kotlin.collections.List", SqlType.Blob);
        sqlTypeMapping.put("kotlin.collections.Set", SqlType.Blob);
        sqlTypeMapping.put("kotlin.collections.Map", SqlType.Blob);
        sqlTypeMapping.put("kotlin.Any", SqlType.Blob);
        sqlTypeMapping.put("java.io.File", SqlType.Blob);
        sqlTypeMapping.put("java.math.BigDecimal", SqlType.Decimal);
        sqlTypeMapping.put("java.time.LocalDateTime", SqlType.DateTime);
        sqlTypeMapping.put("java.time.LocalDate", SqlType.Date);
        sqlTypeMapping.put("java.util.UUID", SqlType.Text);
        sqlTypeMapping.put("java.net.URI", SqlType.Text);

        artifactId = "ktorm";
        artifactVersion = "1.0.0";
        packageName = "org.openapitools.database";

        outputFolder = "generated-code" + File.separator + "kotlin-client";
        embeddedTemplateDir = templateDir = "ktorm-schema";
        modelTemplateFiles.put("model.mustache", ".kt");
        modelDocTemplateFiles.put("model_doc.mustache", ".md");
        modelPackage = packageName + ".models";
        importModelPackageName = modelPackage;

        // we don't clear clioptions from Kotlin
        // cliOptions default redefinition need to be updated
        updateOption(CodegenConstants.ARTIFACT_ID, artifactId);
        updateOption(CodegenConstants.PACKAGE_NAME, packageName);
        removeOption(CodegenConstants.API_SUFFIX);
        removeOption(CodegenConstants.PARCELIZE_MODELS);
        removeOption(CodegenConstants.SERIALIZABLE_MODEL);
        removeOption(CodegenConstants.SERIALIZATION_LIBRARY);
        addOption(DEFAULT_DATABASE_NAME, "Default database name for all queries", defaultDatabaseName);
        addOption(IMPORT_MODEL_PACKAGE_NAME, "Package name of the imported models", importModelPackageName);
        addOption(PRIMARY_KEY_CONVENTION, "Primary key naming convention", primaryKeyConvention);
        addSwitch(ADD_SURROGATE_KEY, "Adds the surrogate key for all models that don't already have a primary key (named by the above convention)", addSurrogateKey);

        // we used to snake_case table/column names, let's add this option
        CliOption identifierNamingOpt = new CliOption(IDENTIFIER_NAMING_CONVENTION,
                "Naming convention of Ktorm identifiers(table names and column names). This is not related to database name which is defined by " + DEFAULT_DATABASE_NAME + " option");

        identifierNamingOpt.addEnum("original", "Do not transform original names")
                .addEnum("snake_case", "Use snake_case names")
                .setDefault("original");

        cliOptions.add(identifierNamingOpt);

    }

    public CodegenType getTag() {
        return CodegenType.SCHEMA;
    }

    public String getName() {
        return "ktorm-schema";
    }

    public String getHelp() {
        return "Generates a kotlin-ktorm schema (beta)";
    }

    @Override
    public void processOpts() {
        super.processOpts();

        if (additionalProperties.containsKey(DEFAULT_DATABASE_NAME)) {
            if (additionalProperties.get(DEFAULT_DATABASE_NAME).equals("")) {
                additionalProperties.remove(DEFAULT_DATABASE_NAME);
            } else {
                setDefaultDatabaseName((String) additionalProperties.get(DEFAULT_DATABASE_NAME));
                // default database name may be escaped, need to overwrite additional prop
                additionalProperties.put(DEFAULT_DATABASE_NAME, getDefaultDatabaseName());
            }
        }

        if (additionalProperties.containsKey(IDENTIFIER_NAMING_CONVENTION)) {
            setIdentifierNamingConvention((String) additionalProperties.get(IDENTIFIER_NAMING_CONVENTION));
        }

        if (additionalProperties.containsKey(IMPORT_MODEL_PACKAGE_NAME)) {
            setImportModelPackageName((String) additionalProperties.get(IMPORT_MODEL_PACKAGE_NAME));
        }

        if (additionalProperties.containsKey(PRIMARY_KEY_CONVENTION)) {
            setPrimaryKeyConvention((String) additionalProperties.get(PRIMARY_KEY_CONVENTION));
        }

        if (additionalProperties.containsKey(ADD_SURROGATE_KEY)) {
            setAddSurrogateKey(convertPropertyToBooleanAndWriteBack(ADD_SURROGATE_KEY));
        }

        // make model src path available in mustache template
        additionalProperties.put("modelSrcPath", "./" + toSrcPath(modelPackage));

        supportingFiles.add(new SupportingFile("README.mustache", "", "README.md"));
        supportingFiles.add(new SupportingFile("build.gradle.mustache", "", "build.gradle"));
        supportingFiles.add(new SupportingFile("settings.gradle.mustache", "", "settings.gradle"));
        supportingFiles.add(new SupportingFile("ktorm_schema.mustache", "", "ktorm_schema.sql"));
    }

    @Override
    public Map postProcessModels(Map objs) {
        objs = super.postProcessModels(objs);

        List