@lightweightform/kotlin-cli
Version:
LF Kotlin CLI Plugin
152 lines • 7.83 kB
JavaScript
;
/*
* @license
* Copyright Lightweightform. All Rights Reserved.
*
* Use of this source code is governed by an Apache2.0-style license that can be
* found at https://www.apache.org/licenses/LICENSE-2.0
*/
var __assign = (this && this.__assign) || function () {
__assign = Object.assign || function(t) {
for (var s, i = 1, n = arguments.length; i < n; i++) {
s = arguments[i];
for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
t[p] = s[p];
}
return t;
};
return __assign.apply(this, arguments);
};
Object.defineProperty(exports, "__esModule", { value: true });
var utils_1 = require("../../utils");
var template_manager_1 = require("../template.manager");
var RecordSchema = /** @class */ (function () {
function RecordSchema() {
}
/**
* Create schema beans in the common maven module
*
* @param schema
* @param basePackage
* @param directory
* @param name
* @param isRoot
* @param isList
*/
RecordSchema.createRecordSchema = function (schema, basePackage, directory, name, isRoot, isList) {
var _this = this;
if (isRoot === void 0) { isRoot = false; }
if (isList === void 0) { isList = false; }
utils_1.createIfCondition(!isRoot, directory);
var fields = [];
var importPackages = [];
Object.keys(schema.fieldsSchemas).forEach(function (fieldName) {
var fieldSchema = schema.fieldsSchemas[fieldName];
var fieldClass = utils_1.camelCase(fieldName);
var isRecordSchema = fieldSchema.type === 'record';
var isListSchema = fieldSchema.type === 'list' || fieldSchema.type === 'table';
var isTupleSchema = fieldSchema.type === 'tuple';
var isCheckboxGroupSchema = RecordSchema.isCheckboxGroupSchema(fieldSchema.elementsSchema);
var fieldBasePackage = "" + basePackage + (isRecordSchema ? "." + fieldName.toLowerCase() + "." : '.') + fieldClass;
var importSchemaPackage = fieldBasePackage + "Schema";
var entrySchemaClass = fieldClass + "EntrySchema";
var entryStorageClass = fieldClass + "Entry";
switch (fieldSchema.type) {
case 'record':
RecordSchema.createRecordSchema(fieldSchema, basePackage + "." + fieldName.toLowerCase(), directory + "/" + fieldName.toLowerCase(), fieldName);
break;
case 'table':
case 'list':
var childSchema = fieldSchema.elementsSchema || fieldSchema.rowsSchema;
if (isCheckboxGroupSchema) {
entrySchemaClass = _this._getTypeSchema(childSchema);
entryStorageClass = utils_1.camelCase(childSchema.type);
importSchemaPackage = "pt.lightweightform.kotlin.schema." + _this._getTypeSchema(childSchema);
}
else {
RecordSchema.createRecordSchema(childSchema, basePackage + "." + fieldName.toLowerCase(), directory + "/" + fieldName.toLowerCase(), "" + fieldName, false, true);
importPackages.push((basePackage + "." + fieldName.toLowerCase() + "." + entryStorageClass).replace('.schema.', '.storage.'));
importPackages.push(basePackage + "." + fieldName.toLowerCase() + "." + entrySchemaClass);
}
importPackages = _this._importPackageIfNotExists(importPackages, 'pt.lightweightform.kotlin.schema.ListSchema');
break;
case 'tuple': // this plugin only support Pairs at this moment
_this._importPackageIfNotExists(importPackages, 'pt.lightweightform.kotlin.schema.PairSchema');
utils_1.throwIfCondition(fieldSchema.elementsSchemas.length !== 2, 'LF-KOTLIN only support Pairs at this moment');
fieldSchema.child1Schema = _this._generatePairSchemaChild(fieldSchema.elementsSchemas[0], importPackages);
fieldSchema.child2Schema = _this._generatePairSchemaChild(fieldSchema.elementsSchemas[1], importPackages);
break;
default:
importSchemaPackage = "pt.lightweightform.kotlin.schema." + _this._getTypeSchema(fieldSchema);
break;
}
importPackages = _this._importSchemaPackage(importPackages, isListSchema, isTupleSchema, isCheckboxGroupSchema, importSchemaPackage);
// pass all schema to field context and additional properties
fields.push(__assign({
fieldName: fieldName,
fieldClass: utils_1.camelCase(fieldClass) + "Schema",
isRecordSchema: isRecordSchema,
isListSchema: isListSchema,
isTupleSchema: isTupleSchema,
typeSchema: _this._getTypeSchema(fieldSchema),
isNumberSchema: fieldSchema.type === 'number',
entrySchemaClass: entrySchemaClass,
entryStorageClass: entryStorageClass,
validationContext: isRoot ? '' : fieldName,
}, fieldSchema));
});
// Write Record Schema class
var className = isList ? utils_1.camelCase(name) + "Entry" : utils_1.camelCase(name);
utils_1.writeFile(directory + "/" + className + "Schema.kt", template_manager_1.default.loadRecordSchema({
name: isRoot ? '' : name,
package: "" + basePackage,
storageTypeImport: (basePackage + "." + className).replace('.schema.', '.storage.'),
schemaType: className + "Schema",
storageType: className,
isRequired: schema.isRequired,
fields: fields,
importPackages: importPackages,
isRoot: isRoot,
}));
};
RecordSchema._importPackageIfNotExists = function (importPackages, packageToImport) {
if (importPackages.indexOf(packageToImport) === -1) {
importPackages.push(packageToImport);
}
return importPackages;
};
RecordSchema.isCheckboxGroupSchema = function (elementType) {
return (elementType &&
(elementType.type === 'string' || elementType.type === 'number'));
};
RecordSchema._getTypeSchema = function (fieldSchema) {
return fieldSchema.type === 'date'
? 'DateStringSchema'
: utils_1.camelCase(fieldSchema.type) + "Schema";
};
RecordSchema._importSchemaPackage = function (importPackages, isListSchema, isTupleSchema, isCheckboxGroupSchema, importSchemaPackage) {
if ((!isListSchema || isCheckboxGroupSchema) &&
!isTupleSchema &&
importPackages.indexOf(importSchemaPackage) === -1) {
importPackages.push(importSchemaPackage);
}
return importPackages;
};
RecordSchema._generatePairSchemaChild = function (elementSchema, importPackages) {
var schemaType = this._getTypeSchema(elementSchema);
this._importPackageIfNotExists(importPackages, "pt.lightweightform.kotlin.schema." + schemaType);
var schemaClass = schemaType + "(";
Object.keys(elementSchema).forEach(function (schemaProp) {
if (schemaProp !== 'type' && schemaProp !== 'initialValue') {
schemaClass += schemaProp + "=" + elementSchema[schemaProp] + ",";
}
});
schemaClass = (schemaClass.charAt(schemaClass.length - 1) === ','
? schemaClass.slice(0, -1)
: schemaClass) + ")";
return schemaClass;
};
return RecordSchema;
}());
exports.RecordSchema = RecordSchema;
//# sourceMappingURL=record.schema.js.map