sasat 0.14.13 → 0.15.1

package/lib/cli/cli.js

@@ -17,7 +17,9 @@ try {
         });
     });
     cli.command('generate', 'generate files').action(generate);
-    cli.command('migration:create [name]', 'generate new migration file').action(createMigration);
+    cli
+        .command('migration:create [name]', 'generate new migration file')
+        .action(createMigration);
     cli.command('dump-db', 'dump database schema').action(dumpDB);
     cli.command('init').action(init);
     cli.parse();

package/lib/cli/commands/dumpDb.js

@@ -8,7 +8,9 @@ import { getDbClient } from '../../db/getDbClient.js';
 export const dumpDB = async () => {
     const con = getDbClient();
     try {
-        const tables = await con.rawQuery('show tables').then(it => it.flatMap(it => Object.values(it)));
+        const tables = await con
+            .rawQuery('show tables')
+            .then(it => it.flatMap(it => Object.values(it)));
         const serialized = await Promise.all(tables.map(table => {
             return con
                 .rawQuery('show create table ' + SqlString.escapeId(table))

package/lib/db/connectors/mariadb/client.js

@@ -1,4 +1,4 @@
-import { DBClient } from '../dbClient.js';
+import { DBClient, } from '../dbClient.js';
 import * as maria from 'mariadb';
 import { config } from '../../../config/config.js';
 import { MariaDBTransaction } from './transaction.js';

package/lib/db/connectors/mysql/client.js

@@ -1,4 +1,4 @@
-import { DBClient } from '../dbClient.js';
+import { DBClient, } from '../dbClient.js';
 import * as mysql from 'mysql2';
 import { MySqlTransaction } from './transaction.js';
 import { config } from '../../../config/config.js';

package/lib/db/formatQuery.js

@@ -5,7 +5,9 @@ export const formatQuery = (str, ...params) => {
         if (typeof params[i] === 'function')
             ret += params[i]();
         else if (Array.isArray(params[i]))
-            ret += params[i].map((it) => SqlString.escape(it)).join(', ');
+            ret += params[i]
+                .map((it) => SqlString.escape(it))
+                .join(', ');
         else
             ret += SqlString.escape(params[i]);
         ret += str[i + 1];

package/lib/db/sql/columnToSql.js

@@ -3,7 +3,9 @@ import { SqlString } from '../../runtime/sql/sqlString.js';
 export const columnToSql = (column) => {
     const words = [SqlString.escapeId(column.columnName), column.type];
     if (column.length)
-        words.push(`(${[column.length, column.scale].filter(it => it !== undefined).join(',')})`);
+        words.push(`(${[column.length, column.scale]
+            .filter(it => it !== undefined)
+            .join(',')})`);
     if (column.signed === true)
         words.push('SIGNED');
     else if (column.signed === false)
@@ -16,7 +18,8 @@ export const columnToSql = (column) => {
         words.push('NOT NULL');
     else if (!column.notNull)
         words.push('NULL');
-    if ((column.type === DBColumnTypes.timestamp || column.type === DBColumnTypes.dateTime) &&
+    if ((column.type === DBColumnTypes.timestamp ||
+        column.type === DBColumnTypes.dateTime) &&
         column.default === 'CURRENT_TIMESTAMP')
         words.push('DEFAULT CURRENT_TIMESTAMP');
     else if (column.default !== undefined)

package/lib/db/sql/condition.js

@@ -1,7 +1,9 @@
 import * as SqlString from 'sqlstring';
-import { conditionExpressionToSql } from './expression/conditionExpression.js';
+import { conditionExpressionToSql, } from './expression/conditionExpression.js';
 const formatTable = (table) => {
-    return typeof table === 'string' ? SqlString.escapeId(table) : table.map(it => SqlString.escapeId(it)).join('as');
+    return typeof table === 'string'
+        ? SqlString.escapeId(table)
+        : table.map(it => SqlString.escapeId(it)).join('as');
 };
 const joinClause = (sql) => {
     if (!sql.join)
@@ -21,7 +23,9 @@ const joinClause = (sql) => {
     })
         .join(' ');
 };
-export const orderToSQL = (order) => order.map(it => `${SqlString.escapeId(it[0])} ${it[1] === 'DESC' ? 'DESC' : 'ASK'}`).join(', ');
+export const orderToSQL = (order) => order
+    .map(it => `${SqlString.escapeId(it[0])} ${it[1] === 'DESC' ? 'DESC' : 'ASK'}`)
+    .join(', ');
 const mergeWhereClause = (whereClauses) => {
     const result = [];
     whereClauses.forEach(it => {
@@ -33,15 +37,22 @@ const mergeWhereClause = (whereClauses) => {
     return result;
 };
 export const createSQLString = (sql) => {
-    const select = [...sql.select, ...(sql.join ? sql.join.flatMap(it => it.select) : [])]
-        .map(it => (Array.isArray(it) ? it.map(it => SqlString.escapeId(it)).join(' as ') : SqlString.escapeId(it)))
+    const select = [
+        ...sql.select,
+        ...(sql.join ? sql.join.flatMap(it => it.select) : []),
+    ]
+        .map(it => Array.isArray(it)
+        ? it.map(it => SqlString.escapeId(it)).join(' as ')
+        : SqlString.escapeId(it))
         .join(', ');
     const join = joinClause(sql);
     const whereClauses = [
         sql.where,
         ...(sql.join ? sql.join.map(it => it.where) : []),
     ].filter(it => it !== undefined && Object.keys(it).length);
-    const where = whereClauses.length === 0 ? '' : ' WHERE ' + conditionExpressionToSql(mergeWhereClause(whereClauses));
+    const where = whereClauses.length === 0
+        ? ''
+        : ' WHERE ' + conditionExpressionToSql(mergeWhereClause(whereClauses));
     const order = sql.order ? ' ORDER BY ' + orderToSQL(sql.order) : '';
     const limit = sql.limit ? ' LIMIT ' + sql.limit : '';
     const offset = sql.offset ? ' OFFSET ' : '';

package/lib/db/sql/createTable/createTableParser.js

@@ -2,6 +2,7 @@ import { TokenKind } from './lexer/lexer.js';
 import { camelize } from '../../../util/stringUtil.js';
 import { columnTypeToGqlPrimitive } from '../../../generator/gql/columnToGqlType.js';
 import { GqlPrimitive } from '../../../generator/gql/types.js';
+import { getDefaultGqlOption } from '../../../migration/data/gqlOption.js';
 const splitArray = (array, callback) => {
     const indexes = [];
     array.forEach((it, i) => {
@@ -49,27 +50,13 @@ export class CreateTableParser {
         this.normalizeFieldName = (fieldName) => {
             return /^[0-9].*/.test(fieldName) ? '_' + fieldName : fieldName;
         };
-        const defaultGqlOption = {
-            mutation: {
-                create: true,
-                update: true,
-                delete: true,
-                fromContextColumns: [],
-            },
-            subscription: {
-                onCreate: false,
-                onUpdate: false,
-                onDelete: false,
-                filter: [],
-            },
-        };
         this.result = {
             tableName: '',
             columns: [],
             primaryKey: [],
             uniqueKeys: [],
             indexes: [],
-            gqlOption: defaultGqlOption,
+            gqlOption: getDefaultGqlOption(),
         };
     }
     resolveParen() {
@@ -104,7 +91,9 @@ export class CreateTableParser {
             const next = tokens[defaultTokenIndex + 1];
             if (next.kind === 'NULL')
                 return undefined;
-            if (next.kind === TokenKind.Number || gqlType === GqlPrimitive.Float || gqlType === GqlPrimitive.Int)
+            if (next.kind === TokenKind.Number ||
+                gqlType === GqlPrimitive.Float ||
+                gqlType === GqlPrimitive.Int)
                 return +next.value;
             if (next.kind === TokenKind.String)
                 return next.value;
@@ -127,8 +116,12 @@ export class CreateTableParser {
             });
         };
         const identifiers = tokens.filter(it => it.kind === TokenKind.Identifier);
-        const length = tokens[2] && isParenToken(tokens[2]) ? tokens[2].tokens[0]?.value : undefined;
-        const scale = tokens[2] && isParenToken(tokens[2]) ? tokens[2].tokens[1]?.value : undefined;
+        const length = tokens[2] && isParenToken(tokens[2])
+            ? tokens[2].tokens[0]?.value
+            : undefined;
+        const scale = tokens[2] && isParenToken(tokens[2])
+            ? tokens[2].tokens[1]?.value
+            : undefined;
         const column = {
             hasReference: false,
             columnName,
@@ -162,17 +155,23 @@ export class CreateTableParser {
     parsePrimary(tokens) {
         const keyIndex = tokens.findIndex(it => it.kind === 'KEY');
         const paren = tokens[keyIndex + 1];
-        this.result.primaryKey = paren.tokens.filter(it => it.kind !== TokenKind.Separator).map(it => it.value);
+        this.result.primaryKey = paren.tokens
+            .filter(it => it.kind !== TokenKind.Separator)
+            .map(it => it.value);
     }
     parseUnique(tokens) {
         const paren = tokens.find(it => it.kind === 'Paren');
-        this.result.uniqueKeys.push(paren.tokens.filter(it => it.kind !== TokenKind.Separator).map(it => it.value));
+        this.result.uniqueKeys.push(paren.tokens
+            .filter(it => it.kind !== TokenKind.Separator)
+            .map(it => it.value));
     }
     parseIndex(tokens) {
         const paren = tokens.find(it => it.kind === 'Paren');
         this.result.indexes.push({
             constraintName: tokens[1].value,
-            columns: paren.tokens.filter(it => it.kind !== TokenKind.Separator && it.kind !== 'Paren').map(it => it.value),
+            columns: paren.tokens
+                .filter(it => it.kind !== TokenKind.Separator && it.kind !== 'Paren')
+                .map(it => it.value),
         });
     }
     parseFkey(tokens) {
@@ -183,7 +182,9 @@ export class CreateTableParser {
         const targetColumn = tokens[refIndex + 2].tokens[0].value;
         let onDelete = undefined;
         let onUpdate = undefined;
-        const on = tokens.map((it, i) => (it.kind === 'ON' ? i : 0)).filter(it => it !== 0);
+        const on = tokens
+            .map((it, i) => (it.kind === 'ON' ? i : 0))
+            .filter(it => it !== 0);
         on.forEach(it => {
             const action = () => {
                 let name = tokens[it + 2].value.toUpperCase();
@@ -199,14 +200,18 @@ export class CreateTableParser {
                 onUpdate = action();
             }
         });
-        const isColumnUnique = this.result.uniqueKeys.filter(it => it.length === 1).find(it => it[0] === columnName);
+        const isColumnUnique = this.result.uniqueKeys
+            .filter(it => it.length === 1)
+            .find(it => it[0] === columnName);
         const sameTableRefs = this.result.columns.filter(it => it.hasReference && it.reference.targetTable === targetTable);
         const reference = {
             targetTable,
             targetColumn,
             columnName,
             relation: isColumnUnique ? 'OneOrZero' : 'Many',
-            relationName: sameTableRefs.length !== 0 ? targetTable + sameTableRefs.length : undefined,
+            relationName: sameTableRefs.length !== 0
+                ? targetTable + sameTableRefs.length
+                : undefined,
             onUpdate,
             onDelete,
         };

package/lib/db/sql/createTable/createTableSerializer.js

@@ -1,4 +1,4 @@
-import { columnTypeToTsType } from '../../../migration/column/columnTypes.js';
+import { columnTypeToTsType, } from '../../../migration/column/columnTypes.js';
 import { lexColumn } from './lexer/columnLexer.js';
 import { TokenKind } from './lexer/lexer.js';
 import { camelize } from '../../../util/stringUtil.js';
@@ -17,7 +17,12 @@ const startStrMap = [
         word: 'PRIMARY KEY',
         fn: (str, table) => {
             const tokens = getInParenValues(lexColumn(str));
-            return { ...table, primaryKey: tokens.filter(it => it.kind === TokenKind.String).map(it => it.value) };
+            return {
+                ...table,
+                primaryKey: tokens
+                    .filter(it => it.kind === TokenKind.String)
+                    .map(it => it.value),
+            };
         },
     },
     {
@@ -27,7 +32,12 @@ const startStrMap = [
             const inParen = getInParenValues(tokens);
             return {
                 ...table,
-                uniqueKeys: [...table.uniqueKeys, inParen.filter(it => it.kind === TokenKind.String).map(it => it.value)],
+                uniqueKeys: [
+                    ...table.uniqueKeys,
+                    inParen
+                        .filter(it => it.kind === TokenKind.String)
+                        .map(it => it.value),
+                ],
             };
         },
     },
@@ -57,7 +67,9 @@ const startStrMap = [
             const refIndex = tokens.findIndex(it => it.kind === TokenKind.Keyword && it.value === 'REFERENCES');
             const targetTable = tokens[refIndex + 1].value;
             const targetColumn = getInParenValues(tokens, refIndex)[0].value;
-            const isColumnUnique = table.uniqueKeys.filter(it => it.length === 1).find(it => it[0] === columnName);
+            const isColumnUnique = table.uniqueKeys
+                .filter(it => it.length === 1)
+                .find(it => it[0] === columnName);
             const sameTableRefs = table.columns.filter(it => it.hasReference && it.reference.targetTable === targetTable);
             const onUpdate = tokens.findIndex(it => it.kind === TokenKind.Keyword && it.value === 'ON UPDATE');
             const onDelete = tokens.findIndex(it => it.kind === TokenKind.Keyword && it.value === 'ON DELETE');
@@ -66,13 +78,21 @@ const startStrMap = [
                 targetColumn,
                 columnName,
                 relation: isColumnUnique ? 'OneOrZero' : 'Many',
-                relationName: sameTableRefs.length !== 0 ? targetTable + sameTableRefs.length : undefined,
-                onUpdate: onUpdate !== -1 ? tokens[onUpdate + 1].value : undefined,
-                onDelete: onDelete !== -1 ? tokens[onDelete + 1].value : undefined,
+                relationName: sameTableRefs.length !== 0
+                    ? targetTable + sameTableRefs.length
+                    : undefined,
+                onUpdate: onUpdate !== -1
+                    ? tokens[onUpdate + 1].value
+                    : undefined,
+                onDelete: onDelete !== -1
+                    ? tokens[onDelete + 1].value
+                    : undefined,
             };
             return {
                 ...table,
-                columns: table.columns.map(it => it.columnName === columnName ? { ...it, hasReference: true, reference } : it),
+                columns: table.columns.map(it => it.columnName === columnName
+                    ? { ...it, hasReference: true, reference }
+                    : it),
             };
         },
     },
@@ -80,7 +100,9 @@ const startStrMap = [
         word: '`',
         fn: (str, table) => {
             const tokens = lexColumn(str);
-            const keywords = tokens.filter(it => it.kind === TokenKind.Keyword).map(it => it.value);
+            const keywords = tokens
+                .filter(it => it.kind === TokenKind.Keyword)
+                .map(it => it.value);
             const getDefault = () => {
                 const index = tokens.findIndex(it => it.kind === TokenKind.Keyword && it.value === 'DEFAULT');
                 if (index === -1)
@@ -88,7 +110,8 @@ const startStrMap = [
                 const next = tokens[index + 1];
                 if (next.kind === TokenKind.String || next.kind === TokenKind.Number)
                     return next;
-                if (next.kind === TokenKind.Identifier && next.value === 'CURRENT_TIMESTAMP')
+                if (next.kind === TokenKind.Identifier &&
+                    next.value === 'CURRENT_TIMESTAMP')
                     return next;
                 return undefined;
             };
@@ -97,7 +120,8 @@ const startStrMap = [
             const getDefaultValue = (defaultToken) => {
                 if (!defaultToken || defaultToken.kind === TokenKind.Identifier)
                     return undefined;
-                if (defaultToken.kind === TokenKind.Keyword && defaultToken.value === 'NULL')
+                if (defaultToken.kind === TokenKind.Keyword &&
+                    defaultToken.value === 'NULL')
                     return null;
                 if (columnTypeToTsType(type) === 'number')
                     return +defaultToken.value;
@@ -112,7 +136,11 @@ const startStrMap = [
                 notNull: keywords.includes('NOT NULL'),
                 default: getDefaultValue(defaultToken),
                 zerofill: keywords.includes('zerofill'),
-                signed: keywords.includes('unsigned') ? false : keywords.includes('signed') ? true : undefined,
+                signed: keywords.includes('unsigned')
+                    ? false
+                    : keywords.includes('signed')
+                        ? true
+                        : undefined,
                 autoIncrement: keywords.includes('AUTO_INCREMENT'),
                 length: inPrenValues.length > 0 ? +inPrenValues[0].value : undefined,
                 scale: inPrenValues.length > 1 ? +inPrenValues[1].value : undefined,

package/lib/db/sql/createTable/lexer/lexer2.js

@@ -34,7 +34,9 @@ export class Lexer2 {
     findOperator(current) {
         const operator = (value) => ({ kind: TokenKind.Operator, value });
         if (!current.hasNext) {
-            return this.operators.includes(current.value) ? operator(current.value) : undefined;
+            return this.operators.includes(current.value)
+                ? operator(current.value)
+                : undefined;
         }
         let operators = this.operators.filter(it => it.startsWith(current.value));
         let state = current.value;

package/lib/db/sql/createTable/lexer/rules.js

@@ -46,7 +46,9 @@ const createKeywordRule = (keywords, ignoreCase = false) => {
         terminator: ['whitespace', 'separator'],
         fn: (start, next) => {
             let str = ignoreCase ? start.toUpperCase() : start;
-            let words = keywords.map(it => typeof it === 'string' ? { kind: TokenKind.Keyword, value: it } : { ...it, value: it.value });
+            let words = keywords.map(it => typeof it === 'string'
+                ? { kind: TokenKind.Keyword, value: it }
+                : { ...it, value: it.value });
             if (ignoreCase)
                 words = words.map(it => ({ ...it, value: it.value.toUpperCase() }));
             let v;

package/lib/db/sql/expression/comparison.js

@@ -12,7 +12,9 @@ export var Comparison;
     Comparison["notLike"] = "NOT LIKE";
 })(Comparison || (Comparison = {}));
 export const comparisonExpressionToSql = (exp) => {
-    const type = Object.prototype.hasOwnProperty.call(exp, '__type') ? exp.__type || 'AND' : 'AND';
+    const type = Object.prototype.hasOwnProperty.call(exp, '__type')
+        ? exp.__type || 'AND'
+        : 'AND';
     return Object.entries(exp)
         .map(([key, value]) => {
         const column = SqlString.escapeId(key);
@@ -24,7 +26,9 @@ export const comparisonExpressionToSql = (exp) => {
             return `${column} IS NOT NULL`;
         if (value[0] === 'IN') {
             const [, ...columns] = value;
-            return `${column} IN (${[columns.map(column => SqlString.escape(column)).join(', ')]})`;
+            return `${column} IN (${[
+                columns.map(column => SqlString.escape(column)).join(', '),
+            ]})`;
         }
         if (value[0] === 'BETWEEN')
             return `${column} BETWEEN ${SqlString.escape(value[1])} AND ${SqlString.escape(value[2])}`;

package/lib/db/sql/expression/compositeCondition.js

@@ -1,4 +1,4 @@
-import { conditionExpressionToSql } from './conditionExpression.js';
+import { conditionExpressionToSql, } from './conditionExpression.js';
 export class CompositeCondition {
     constructor(type, conditions) {
         this.type = type;
@@ -11,6 +11,6 @@ export class CompositeCondition {
         return new CompositeCondition('AND', conditions);
     }
     toSQL() {
-        return '(' + this.conditions.map(conditionExpressionToSql).join(this.type) + ')';
+        return ('(' + this.conditions.map(conditionExpressionToSql).join(this.type) + ')');
     }
 }

package/lib/db/sql/expression/conditionExpression.js

@@ -1,4 +1,4 @@
-import { comparisonExpressionToSql } from './comparison.js';
+import { comparisonExpressionToSql, } from './comparison.js';
 import { CompositeCondition } from './compositeCondition.js';
 export const conditionExpressionToSql = (exp) => {
     if (Array.isArray(exp)) {

package/lib/db/sql/sqlCreater.js

@@ -5,8 +5,12 @@ export const SqlCreator = {
     addUniqueKey: (tableName, columns) => `ALTER TABLE ${tableName} ADD UNIQUE ${columns.join('__')}(${columns.join(',')})`,
     addPrimaryKey: (tableName, columns) => `ALTER TABLE ${tableName} ADD PRIMARY KEY ${columns.join('__')}(${columns.join(',')})`,
     addForeignKey: (tableName, constraintName, reference) => {
-        const onUpdate = reference.onUpdate ? ' ON UPDATE ' + reference.onUpdate : '';
-        const onDelete = reference.onDelete ? ' ON DELETE ' + reference.onDelete : '';
+        const onUpdate = reference.onUpdate
+            ? ' ON UPDATE ' + reference.onUpdate
+            : '';
+        const onDelete = reference.onDelete
+            ? ' ON DELETE ' + reference.onDelete
+            : '';
         return `ALTER TABLE ${tableName} ADD CONSTRAINT '${constraintName}' FOREIGN KEY (${reference.columnName}) REFERENCES ${reference.targetTable}(${reference.targetColumn})${onUpdate}${onDelete}`;
     },
 };

package/lib/generator/gql/Directive.d.ts

@@ -0,0 +1,13 @@
+import { DirectiveLocation } from "graphql";
+declare type DirectiveArgs = {
+    name: string;
+    type: string;
+    default: any;
+};
+declare type Directive = {
+    types: DirectiveLocation[];
+    args: DirectiveArgs[];
+    name: string;
+};
+export declare const directiveToTypeDefs: (directive: Directive) => string;
+export {};

package/lib/generator/gql/Directive.js

@@ -0,0 +1,3 @@
+export const directiveToTypeDefs = (directive) => {
+    return `directive @${directive.name}() on ${directive.types.join(' | ')}`;
+};

package/lib/generator/ts/code/importDeclaration.js

@@ -5,7 +5,8 @@ export class ImportDeclaration {
         this.module = module;
     }
     toString() {
-        const addJsExt = config().generator.addJsExtToImportStatement && this.module.startsWith('.');
+        const addJsExt = config().generator.addJsExtToImportStatement &&
+            this.module.startsWith('.');
         return `import {${this.types.join(',')}} from "${addJsExt ? this.module + '.js' : this.module}";`;
     }
 }

package/lib/generator/ts/code/node/class.js

@@ -37,6 +37,7 @@ export class Class extends ExportableDeclaration {
         const implement = this._implements ? this._implements.toString() + ' ' : '';
         const extend = this._extends ? this._extends.toString() + '' : '';
         const modifier = this.isAbstract ? 'abstract ' : '';
-        return modifier + `class ${this.name} ${implement}${extend}{${properties}${methods}}`;
+        return (modifier +
+            `class ${this.name} ${implement}${extend}{${properties}${methods}}`);
     }
 }

package/lib/generator/ts/code/node/enumDeclaration.js

@@ -12,6 +12,8 @@ export class EnumDeclaration extends ExportableDeclaration {
         return this;
     }
     toTsString() {
-        return `enum ${this.identifier}{${this.members.map(it => it.toString() + ',').join('')}}`;
+        return `enum ${this.identifier}{${this.members
+            .map(it => it.toString() + ',')
+            .join('')}}`;
     }
 }

package/lib/generator/ts/code/node/expressions.js

@@ -1,6 +1,7 @@
 import { TsCode } from '../abstruct/tsCode.js';
 import { ExpressionStatement } from './expressionStatement.js';
 import { Parameter } from './parameter.js';
+import { tsValueString } from "../../tsValueString.js";
 export class TsExpression extends TsCode {
     constructor() {
         super(...arguments);
@@ -30,7 +31,8 @@ export class CallExpression extends TsExpression {
         this.args = args;
     }
     toTsString() {
-        return this.identifier.toString() + `(${this.args.map(it => it.toString()).join(',')})`;
+        return (this.identifier.toString() +
+            `(${this.args.map(it => it.toString()).join(',')})`);
     }
 }
 export class Literal extends TsExpression {
@@ -41,8 +43,9 @@ export class StringLiteral extends Literal {
         this.value = value;
     }
     toTsString() {
-        return `'${this.value.replace("'", "\\'")}'`;
+        return tsValueString(this.value);
     }
+    ;
 }
 export class NumericLiteral extends Literal {
     constructor(value) {

package/lib/generator/ts/code/node/interface.d.ts

@@ -1,11 +1,14 @@
 import { PropertySignature } from './propertySignature.js';
 import { ExportableDeclaration } from '../abstruct/exportableDeclaration.js';
 import { TsType } from './type/type.js';
+import { ExtendsClause } from "./extendsClause";
 export declare class TsInterface extends ExportableDeclaration {
     private readonly name;
     private properties;
+    private _extends?;
     constructor(name: string);
     addProperty(propertyName: string, type: TsType, isOptional?: boolean, isReadOnly?: boolean): this;
     addProperties(properties: PropertySignature[]): this;
+    extends(value: ExtendsClause): this;
     protected toTsString(): string;
 }

package/lib/generator/ts/code/node/interface.js

@@ -15,7 +15,15 @@ export class TsInterface extends ExportableDeclaration {
         this.mergeImport(...properties);
         return this;
     }
+    extends(value) {
+        this._extends = value;
+        this.mergeImport(value);
+        return this;
+    }
     toTsString() {
-        return `interface ${this.name}{${this.properties.map(it => it.toString()).join(';')}}`;
+        const extend = this._extends ? this._extends.toString() + ' ' : '';
+        return `interface ${this.name} ${extend}{${this.properties
+            .map(it => it.toString())
+            .join(';')}}`;
     }
 }

package/lib/generator/ts/code/node/propertyDeclaration.js

@@ -23,7 +23,9 @@ export class PropertyDeclaration extends TsCode {
         return this;
     }
     toTsString() {
-        const initializer = this._initializer ? ` = ${this._initializer.toString()}` : '';
+        const initializer = this._initializer
+            ? ` = ${this._initializer.toString()}`
+            : '';
         return (this._modifiers.toString() +
             `${this.propertyName}${TsUtil.questionToken(this.optional)}: ${this.type}` +
             initializer +

package/lib/generator/ts/code/node/type/typeReference.js

@@ -16,10 +16,15 @@ export class TypeReference extends TsCode {
         return new TypeReference('Partial', [this]);
     }
     pick(...properties) {
-        return new TypeReference('Pick', [this, new Identifier(properties.map(it => `'${it}'`).join('|'))]);
+        return new TypeReference('Pick', [
+            this,
+            new Identifier(properties.map(it => `'${it}'`).join('|')),
+        ]);
     }
     toTsString() {
-        const typeArgs = this.typeArguments.length === 0 ? '' : `<${this.typeArguments.join(',')}>`;
+        const typeArgs = this.typeArguments.length === 0
+            ? ''
+            : `<${this.typeArguments.join(',')}>`;
         return `${this.typeName}${typeArgs}`;
     }
 }

package/lib/generator/ts/code/node/variableDeclaration.js

@@ -6,7 +6,10 @@ export class VariableDeclaration extends ExportableDeclaration {
         this.flag = flag;
         this.expression = expression;
         this.type = type;
-        this.variableName = typeof variableName === 'string' ? new Identifier(variableName) : variableName;
+        this.variableName =
+            typeof variableName === 'string'
+                ? new Identifier(variableName)
+                : variableName;
         this.mergeImport(expression, this.variableName, type);
     }
     toTsString() {