mythix-orm 1.5.5 → 1.6.1

package/lib/connection/connection-base.d.ts

@@ -0,0 +1,180 @@
+import { EventEmitter } from 'events';
+import { Moment } from 'moment';
+import { Literals } from '.';
+import Field from '../field';
+import { GenericObject } from '../interfaces/common';
+import { IterateFieldsCallback, ModelClass, Models, Model, HookContext, DirtyChanges } from '../model';
+import { QueryEngine, QueryEngineClass } from '../query-engine/query-engine';
+import { BigIntType, BlobType, BooleanType, CharType, DateTimeType, DateType, IntegerType, NumericType, RealType, StringType, TextType, Type, UUIDV1Type, UUIDV3Type, UUIDV4Type, UUIDV5Type, XIDType } from '../types';
+import { DefaultValueContext } from '../types/helpers';
+import { FullyQualifiedFieldDefinition } from '../utils/model-utils';
+import { AverageLiteral, CountLiteral, DistinctLiteral, FieldLiteral, MaxLiteral, MinLiteral, SumLiteral } from './literals';
+import LiteralBase from './literals/literal-base';
+import QueryGeneratorBase from './query-generator-base';
+
+export declare interface ConnectionBaseOptions {
+  QueryEngine: QueryEngineClass;
+  queryGenerator: QueryGeneratorBase;
+  models: Models | Array<ModelClass>;
+}
+
+export declare type ModelCache = Map<ModelClass, Map<string, any>>;
+
+export declare interface PreparedModels {
+  models: Array<Model>;
+  dirtyFields: Array<Field>;
+  dirtyModels: Array<Model>;
+  _mythixPreparedModels: boolean;
+}
+
+export declare interface LockModeOptions {
+  modelName?: string;
+  lock?: boolean;
+  read?: boolean;
+  write?: boolean;
+}
+
+export declare interface LockMode {
+  modelName?: string;
+  lock: boolean;
+  read: boolean;
+  write: boolean;
+}
+
+export declare interface QueryResults {
+  rows: Array<any>;
+  columns: Array<string>;
+}
+
+export declare interface DirtyFieldHelperContext {
+  options: GenericObject;
+  fieldData: GenericObject;
+  dirtyFieldData: GenericObject;
+  dirtyFields: DirtyChanges;
+  field: Field;
+  fieldName: string;
+}
+
+declare class ConnectionBase extends EventEmitter {
+  declare public static Literals: typeof Literals;
+  declare public static dialect: string;
+  declare public static _isMythixConnection: boolean;
+
+  public static isConnectionClass(value: any): boolean;
+  public static isConnection(value: any): boolean;
+  public static getLiteralClassByName(name: string): typeof LiteralBase;
+  public static Literal(name: string, ...args: Array<any>): LiteralBase;
+
+  declare public dialect: string;
+  declare protected _models: Models;
+  declare protected _options: ConnectionBaseOptions;
+  declare protected _modelCache: ModelCache;
+  declare protected queryGenerator: any; // TODO: Needs proper type
+
+  public constructor(options?: ConnectionBaseOptions);
+  public getLockMode(options: string | LockModeOptions): LockMode;
+  public getDefaultOrder(Model: ModelClass, options?: GenericObject): Array<string>;
+  public isLimitSupportedInContext(options?: GenericObject): boolean;
+  public isOrderSupportedInContext(options?: GenericObject): boolean | string;
+  public _getFromModelCache(Model: ModelClass, key: string, defaultValue?: any): any;
+  public _setToModelCache<T>(Model: ModelClass, key: string, value: T): T;
+  public getOptions(): ConnectionBaseOptions;
+  public isStarted(): boolean;
+  public toQueryEngine(queryEngineLike: any): QueryEngine | undefined;
+  public registerModel<T = ModelClass>(Model: T): T;
+  public registerModels(models: Models | Array<ModelClass>): Models | undefined;
+  public findModelField(finder: IterateFieldsCallback): Array<Field>;
+  public parseQualifiedName(fullyQualifiedName: string): FullyQualifiedFieldDefinition;
+  public getModels(): Models;
+  public getModel(modelName: string): ModelClass | undefined;
+  public getField(fieldName: string, modelName?: string): Field | undefined;
+  public getQueryEngineClass(): QueryEngineClass;
+  public getQueryGenerator(): QueryGeneratorBase;
+  public setQueryGenerator(queryGenerator: QueryGeneratorBase): void;
+  public _escape(value: any): string;
+  public escape(field: Field, value: any, options?: GenericObject): string;
+  public _escapeID(value: string): string;
+  public escapeID(value: LiteralBase | string, options?: GenericObject): string;
+  public _averageLiteralToString(literal: AverageLiteral, options?: GenericObject): string;
+  public _countLiteralToString(literal: CountLiteral, options?: GenericObject): string;
+  public _distinctLiteralToString(literal: DistinctLiteral, options?: GenericObject): string;
+  public _fieldLiteralToString(literal: FieldLiteral, options?: GenericObject): string;
+  public _maxLiteralToString(literal: MaxLiteral, options?: GenericObject): string;
+  public _minLiteralToString(literal: MinLiteral, options?: GenericObject): string;
+  public _sumLiteralToString(literal: SumLiteral, options?: GenericObject): string;
+  public literalToString(literal: LiteralBase, options?: GenericObject): string;
+  public _bigintTypeToString(type: BigIntType): string;
+  public _blobTypeToString(type: BlobType): string;
+  public _booleanTypeToString(type: BooleanType): string;
+  public _charTypeToString(type: CharType): string;
+  public _dateTypeToString(type: DateType): string;
+  public _datetimeTypeToString(type: DateTimeType): string;
+  public _numericTypeToString(type: NumericType): string;
+  public _realTypeToString(type: RealType): string;
+  public _integerTypeToString(type: IntegerType);
+  public _stringTypeToString(type: StringType): string
+  public _textTypeToString(type: TextType): string;
+  public _uuidV1TypeToString(type: UUIDV1Type): string;
+  public _uuidV3TypeToString(type: UUIDV3Type): string;
+  public _uuidV4TypeToString(type: UUIDV4Type): string;
+  public _uuidV5TypeToString(type: UUIDV5Type): string;
+  public _xidTypeToString(type: XIDType): string;
+  public typeToString(type: Type, options?: GenericObject): string;
+  public convertDateToDBTime(value: Date | Moment): Date;
+  public ensureAllModelsAreInstances(Model: ModelClass, models: Array<Model | GenericObject> | PreparedModels, options?: GenericObject): Array<Model>;
+  public prepareAllModelsForOperation(Model: ModelClass, models: Array<Model | GenericObject> | PreparedModels, options?: GenericObject): PreparedModels;
+  public splitModelAndSubModels(Model: ModelClass, primaryModel: Model, relationMap?: Map<string, Set<Model>>): Map<string, Set<Model>>;
+  public prepareAllModelsAndSubModelsForOperation(Model: ModelClass, models: Array<Model>, options?: GenericObject): Map<string, Array<Model>>;
+
+  public bulkModelOperation(
+    Model: ModelClass,
+    models: Array<Model | GenericObject> | PreparedModels,
+    options: GenericObject | null | undefined,
+    beforeCallback: ((Model: ModelClass, batchModelInstances: Array<Model>, options: GenericObject, queryGenerator: QueryGeneratorBase) => Promise<void>) | null | undefined,
+    callback: (Model: ModelClass, preparedModels: PreparedModels, options: GenericObject, queryGenerator: QueryGeneratorBase) => Promise<void>,
+    afterCallback: ((Model: ModelClass, models: Array<Model>, options: GenericObject, queryGenerator: QueryGeneratorBase) => Promise<void>) | null | undefined,
+    afterOperationCallback: ((Model: ModelClass, dirtyModels: Set<Model>, options: GenericObject, queryGenerator: QueryGeneratorBase) => Promise<void>) | null | undefined,
+  ): Promise<Array<Model> | undefined>;
+
+  public setPersisted(models: Array<Models> | PreparedModels, value: boolean): void;
+  public start(): Promise<void>;
+  public stop(): Promise<void>;
+
+  public runSaveHooks(Model: ModelClass, models: Array<Model>, operationHookName: string, saveHookName: string, options: GenericObject): Promise<Array<any>>;
+  public dropTable(Model: ModelClass, options?: GenericObject): Promise<any>;
+  public dropTables(Models: Models, options?: GenericObject): Promise<Array<any>>;
+  public createTable(Model: ModelClass, options?: GenericObject): Promise<any>;
+  public createTables(Models: Models, options?: GenericObject): Promise<Array<any>>;
+  public defineTable(): Promise<any>;
+  public defineConstraints(): Promise<any>;
+  public defineIndexes(): Promise<any>;
+  public renameTable(): Promise<any>;
+  public renameColumn(): Promise<any>;
+  public dropColumn(): Promise<any>;
+  public alterColumn(): Promise<any>;
+  public addColumn(): Promise<any>;
+  public addConstraint(): Promise<any>;
+  public addIndex(): Promise<any>;
+  public insert(Model: ModelClass, models: Array<Model | GenericObject> | Model | GenericObject, options?: GenericObject): Promise<Array<Models> | undefined>;
+  public upsert(Model: ModelClass, models: Array<Model | GenericObject> | Model | GenericObject, options?: GenericObject): Promise<Array<Models> | undefined>;
+  public update(Model: ModelClass, models: Array<Model | GenericObject> | Model | GenericObject, options?: GenericObject): Promise<Array<Models> | undefined>;
+  public updateAll(queryEngine: QueryEngine | ModelClass, model: Model | GenericObject, options?: GenericObject): Promise<any>;
+  public destroyModels(Model: ModelClass, models: Array<Model> | Model, options?: GenericObject): Promise<Array<Model>>;
+  public destroy(queryEngineOrModel: QueryEngine | ModelClass, modelsOrOptions: Array<Models> | Model | GenericObject, options?: GenericObject): Promise<any>;
+  public select(queryEngine: QueryEngine, options?: GenericObject): AsyncIterator<Model>;
+  public aggregate(queryEngine: QueryEngine, literal: LiteralBase, options?: GenericObject): Promise<number>;
+  public average(queryEngine: QueryEngine, field: Field | string, options?: GenericObject): Promise<number>;
+  public count(queryEngine: QueryEngine, field: Field | string, options?: GenericObject): Promise<number>;
+  public min(queryEngine: QueryEngine, field: Field | string, options?: GenericObject): Promise<number>;
+  public max(queryEngine: QueryEngine, field: Field | string, options?: GenericObject): Promise<number>;
+  public sum(queryEngine: QueryEngine, field: Field | string, options?: GenericObject): Promise<number>;
+  public pluck(queryEngine: QueryEngine, fields: Array<Field> | Array<string> | Field | string, options?: GenericObject): Promise<Array<any> | Array<Array<any>>>;
+  public exists(queryEngine: QueryEngine, options?: GenericObject): Promise<boolean>;
+  public truncate(Model: ModelClass, options?: GenericObject): Promise<void>;
+  public query(sql: string | GenericObject, options?: GenericObject): Promise<any>;
+  public transaction(callback: (connection: ConnectionBase) => any, options?: GenericObject): Promise<any>;
+  public getDefaultFieldValue(type: string | LiteralBase, context: DefaultValueContext): Promise<any>;
+  public dirtyFieldHelper(context: DirtyFieldHelperContext): any;
+}
+
+export default ConnectionBase;

package/lib/connection/connection-base.js

@@ -1,15 +1,15 @@
 'use strict';
 
-const moment              = require('moment');
-const EventEmitter        = require('events');
-const Nife                = require('nife');
-const SqlString           = require('sqlstring');
-const { QueryEngine }     = require('../query-engine');
-const Utils               = require('../utils');
-const ModelBase           = require('../model');
-const Literals            = require('./literals');
-const QueryGeneratorBase  = require('./query-generator-base');
-const Types               = require('../types');
+const moment                = require('moment');
+const EventEmitter          = require('events');
+const Nife                  = require('nife');
+const SqlString             = require('sqlstring');
+const { QueryEngine }       = require('../query-engine');
+const Utils                 = require('../utils');
+const { Model: ModelBase }  = require('../model');
+const Literals              = require('./literals');
+const QueryGeneratorBase    = require('./query-generator-base');
+const Types                 = require('../types');
 
 const LiteralBase = Literals.LiteralBase;
 
@@ -18,6 +18,8 @@ const LiteralBase = Literals.LiteralBase;
 ///
 /// Alias: Connection
 class ConnectionBase extends EventEmitter {
+  static Literals = Literals;
+
   static dialect = 'none';
 
   static _isMythixConnection = true;
@@ -48,6 +50,29 @@ class ConnectionBase extends EventEmitter {
     return false;
   }
 
+  static getLiteralClassByName(_name) {
+    if (!_name)
+      return;
+
+    let name = Nife.capitalize(_name.toLowerCase());
+
+    if (name === 'Literal')
+      return Literals.Literal;
+    else if (name === 'Base')
+      return Literals.LiteralBase;
+
+    return Literals[`${name}Literal`];
+  }
+
+  static Literal(name, ...args) {
+    const LiteralClass = this.getLiteralClassByName(name);
+    if (!LiteralClass)
+      throw new Error(`${this.constructor.name}::Literal: Unable to locate literal class for literal name "${name}".`);
+
+    let literal = new LiteralClass(...args);
+    return literal;
+  }
+
   constructor(_options) {
     super();
 
@@ -62,7 +87,7 @@ class ConnectionBase extends EventEmitter {
 
     Object.defineProperties(this, {
       'dialect': {
-        enumberable:  false,
+        enumerable:   false,
         configurable: true,
         get:          () => {
           return this.constructor.dialect;
@@ -72,25 +97,25 @@ class ConnectionBase extends EventEmitter {
       },
       '_models': {
         writable:     true,
-        enumberable:  false,
+        enumerable:   false,
         configurable: true,
         value:        {},
       },
       '_options': {
         writable:     true,
-        enumberable:  false,
+        enumerable:   false,
         configurable: true,
         value:        options,
       },
       '_modelCache': {
         writable:     true,
-        enumberable:  false,
+        enumerable:   false,
         configurable: true,
         value:        new Map(),
       },
       'queryGenerator': {
         writable:     true,
-        enumberable:  false,
+        enumerable:   false,
         configurable: true,
         value:        options.queryGenerator,
       },
@@ -99,6 +124,32 @@ class ConnectionBase extends EventEmitter {
     this.registerModels(options.models);
   }
 
+  getLockMode(options) {
+    if (!options)
+      return { lock: false, read: false, write: false };
+
+    const throwError = () => {
+      throw new Error(`${this.constructor.name}::getLockMode: "lock" must be the name of a model (lock: "ModelName"), or an object specifying the model and the lock mode (lock: { modelName: "ModelName", read: true, write: true, dependents: true, noWait: false }).`);
+    };
+
+    if (Nife.instanceOf(options, 'string')) {
+      let Model = this.getModel(options);
+      if (!Model)
+        throwError();
+
+      return { lock: true, modelName: options, read: true, write: true };
+    } else if (Nife.instanceOf(options, 'object')) {
+      let modelName = options.modelName;
+      let Model = this.getModel(modelName);
+      if (!Model)
+        throwError();
+
+      return Object.assign({ lock: true, modelName, read: true, write: true }, options);
+    } else {
+      throwError();
+    }
+  }
+
   getDefaultOrder(Model, options) {
     let order = Model.defaultOrder(options);
     if (!order)
@@ -121,6 +172,23 @@ class ConnectionBase extends EventEmitter {
     return order.map((value) => ((value.indexOf(':') < 0) ? `${modelName}:${value}` : value));
   }
 
+  isLimitSupportedInContext(options) {
+    return true;
+  }
+
+  isOrderSupportedInContext(_options) {
+    let options = _options || {};
+    if (options.isSubQuery) {
+      let subQueryOperator = options.subQueryOperator;
+      if (subQueryOperator === 'EXISTS' || subQueryOperator === 'NOT EXISTS')
+        return true;
+
+      return 'PROJECTION_ONLY';
+    }
+
+    return true;
+  }
+
   _getFromModelCache(Model, key, defaultValue) {
     let cache = this._modelCache.get(Model);
     if (!cache)
@@ -324,6 +392,17 @@ class ConnectionBase extends EventEmitter {
     return queryGenerator._distinctLiteralToString(literal, options);
   }
 
+  _fieldLiteralToString(literal, options) {
+    if (!literal || !LiteralBase.isLiteral(literal))
+      return;
+
+    let queryGenerator = this.getQueryGenerator();
+    if (!queryGenerator)
+      return;
+
+    return queryGenerator._fieldLiteralToString(literal, options);
+  }
+
   _maxLiteralToString(literal, options) {
     if (!literal || !LiteralBase.isLiteral(literal))
       return;
@@ -364,6 +443,8 @@ class ConnectionBase extends EventEmitter {
       return this._countLiteralToString(literal, options);
     else if (Literals.DistinctLiteral.isLiteralType(literal))
       return this._distinctLiteralToString(literal, options);
+    else if (Literals.FieldLiteral.isLiteralType(literal))
+      return this._fieldLiteralToString(literal, options);
     else if (Literals.MaxLiteral.isLiteralType(literal))
       return this._maxLiteralToString(literal, options);
     else if (Literals.MinLiteral.isLiteralType(literal))
@@ -601,7 +682,7 @@ class ConnectionBase extends EventEmitter {
     Object.defineProperties(finalResult, {
       '_mythixPreparedModels': {
         writable:     true,
-        enumberable:  false,
+        enumerable:   false,
         configurable: true,
         value:        finalResult,
       },
@@ -909,6 +990,156 @@ class ConnectionBase extends EventEmitter {
     this.removeAllListeners();
   }
 
+  async runSaveHooks(Model, models, operationHookName, saveHookName, options) {
+    const throwError = (error) => {
+      throw error;
+    };
+
+    let promises  = [];
+    let context   = { connection: this, Model, options, self: null };
+
+    for (let i = 0, il = models.length; i < il; i++) {
+      let model = models[i];
+
+      context.self = model;
+
+      let promise = model[operationHookName](context);
+      if (!Nife.instanceOf(promise, 'promise'))
+        promise = Promise.resolve(promise);
+
+      promise = promise.then(async () => await model[saveHookName](context), throwError);
+      if (!Nife.instanceOf(promise, 'promise'))
+        promise = Promise.resolve(promise);
+
+      promises.push(promise);
+    }
+
+    await Promise.all(promises);
+  }
+
+  async dropTable(Model, options) {
+    throw new Error(`${this.constructor.name}::dropTable: This operation is not supported for this connection type.`);
+  }
+
+  async dropTables(_Models, options) {
+    if (!_Models)
+      return;
+
+    // First we collect all models and put them into a map
+    let modelMap = _Models;
+
+    if (Nife.instanceOf(_Models, 'array', 'function')) {
+      modelMap = {};
+
+      let Models = Nife.toArray(_Models).filter(Boolean);
+      for (let i = 0, il = Models.length; i < il; i++) {
+        let Model     = Models[i];
+        let modelName = Model.getModelName();
+
+        modelMap[modelName] = Model;
+      }
+    }
+
+    // Second we sort the model names in creation order,
+    // and going in reverse of that order we destroy
+    // each table.
+    let modelNames        = Object.keys(modelMap);
+    let sortedModelNames  = Utils.sortModelNamesByCreationOrder(this, modelNames);
+    let results           = [];
+
+    for (let i = sortedModelNames.length - 1; i >= 0; i--) {
+      let modelName = sortedModelNames[i];
+      let Model     = modelMap[modelName];
+
+      results.push(await this.dropTable(Model, options));
+    }
+
+    return results;
+  }
+
+  async createTable(Model, options) {
+    throw new Error(`${this.constructor.name}::createTable: This operation is not supported for this connection type.`);
+  }
+
+  async createTables(_Models, options) {
+    if (!_Models)
+      return;
+
+    // First we collect all models and put them into a map
+    let modelMap = _Models;
+
+    if (Nife.instanceOf(_Models, 'array', 'function')) {
+      modelMap = {};
+
+      let Models = Nife.toArray(_Models).filter(Boolean);
+      for (let i = 0, il = Models.length; i < il; i++) {
+        let Model     = Models[i];
+        let modelName = Model.getModelName();
+
+        modelMap[modelName] = Model;
+      }
+    }
+
+    // Second we sort the model names in creation order,
+    // and then create the tables in that order
+    let modelNames        = Object.keys(modelMap);
+    let sortedModelNames  = Utils.sortModelNamesByCreationOrder(this, modelNames);
+    let results           = [];
+
+    for (let i = 0, il = sortedModelNames.length; i < il; i++) {
+      let modelName = sortedModelNames[i];
+      let Model     = modelMap[modelName];
+
+      results.push(await this.createTable(Model, options));
+    }
+
+    return results;
+  }
+
+  // Define operations
+
+  async defineTable() {
+    throw new Error(`${this.constructor.name}::defineTable: This operation is not supported for this connection type.`);
+  }
+
+  async defineConstraints() {
+    throw new Error(`${this.constructor.name}::defineConstraints: This operation is not supported for this connection type.`);
+  }
+
+  async defineIndexes() {
+    throw new Error(`${this.constructor.name}::defineIndexes: This operation is not supported for this connection type.`);
+  }
+
+  // Alter operations
+
+  async renameTable() {
+    throw new Error(`${this.constructor.name}::renameTable: This operation is not supported for this connection type.`);
+  }
+
+  async renameColumn() {
+    throw new Error(`${this.constructor.name}::renameColumn: This operation is not supported for this connection type.`);
+  }
+
+  async dropColumn() {
+    throw new Error(`${this.constructor.name}::dropColumn: This operation is not supported for this connection type.`);
+  }
+
+  async alterColumn() {
+    throw new Error(`${this.constructor.name}::alterColumn: This operation is not supported for this connection type.`);
+  }
+
+  async addColumn() {
+    throw new Error(`${this.constructor.name}::addColumn: This operation is not supported for this connection type.`);
+  }
+
+  async addConstraint() {
+    throw new Error(`${this.constructor.name}::addConstraint: This operation is not supported for this connection type.`);
+  }
+
+  async addIndex() {
+    throw new Error(`${this.constructor.name}::addIndex: This operation is not supported for this connection type.`);
+  }
+
   // eslint-disable-next-line no-unused-vars
   async insert(Model, models, _options) {
     throw new Error(`${this.constructor.name}::insert: This operation is not supported for this connection type.`);
@@ -983,6 +1214,31 @@ class ConnectionBase extends EventEmitter {
   async exists(queryEngine, options) {
     throw new Error(`${this.constructor.name}::exists: This operation is not supported for this connection type.`);
   }
+
+  // eslint-disable-next-line no-unused-vars
+  async truncate(Model, options) {
+    throw new Error(`${this.constructor.name}::truncate: This operation is not supported for this connection type.`);
+  }
+
+  // eslint-disable-next-line no-unused-vars
+  async query(sql, options) {
+    throw new Error(`${this.constructor.name}::transaction: This operation is not supported for this connection type.`);
+  }
+
+  // eslint-disable-next-line no-unused-vars
+  async transaction(callback, options) {
+    throw new Error(`${this.constructor.name}::transaction: This operation is not supported for this connection type.`);
+  }
+
+  // eslint-disable-next-line no-unused-vars
+  async getDefaultFieldValue(type, context) {
+    throw new Error(`${this.constructor.name}::getDefaultFieldValue: This operation is not supported for this connection type.`);
+  }
+
+  // eslint-disable-next-line no-unused-vars
+  dirtyFieldHelper(context) {
+
+  }
 }
 
 module.exports = ConnectionBase;

package/lib/connection/index.d.ts

@@ -0,0 +1,5 @@
+export * as Literals from './literals';
+export * from './connection-base';
+export { default as ConnectionBase } from './connection-base';
+export * from './query-generator-base';
+export { default as QueryGeneratorBase } from './query-generator-base';

package/lib/connection/literals/average-literal.d.ts

@@ -0,0 +1,5 @@
+import LiteralFieldBase from './literal-field-base';
+
+declare class AverageLiteral extends LiteralFieldBase { }
+
+export default AverageLiteral;

package/lib/connection/literals/count-literal.d.ts

@@ -0,0 +1,5 @@
+import LiteralFieldBase from './literal-field-base';
+
+declare class CountLiteral extends LiteralFieldBase { }
+
+export default CountLiteral;

package/lib/connection/literals/distinct-literal.d.ts

@@ -0,0 +1,5 @@
+import LiteralFieldBase from './literal-field-base';
+
+declare class DistinctLiteral extends LiteralFieldBase { }
+
+export default DistinctLiteral;

package/lib/connection/literals/field-literal.d.ts

@@ -0,0 +1,5 @@
+import LiteralFieldBase from './literal-field-base';
+
+declare class FieldLiteral extends LiteralFieldBase { }
+
+export default FieldLiteral;

package/lib/connection/literals/field-literal.js

@@ -0,0 +1,14 @@
+'use strict';
+
+const LiteralFieldBase = require('./literal-field-base');
+
+class FieldLiteral extends LiteralFieldBase {
+  toString(connection, options) {
+    if (!connection)
+      return `${this.constructor.name} {}`;
+
+    return connection.literalToString(this, options);
+  }
+}
+
+module.exports = FieldLiteral;

package/lib/connection/literals/index.d.ts

@@ -0,0 +1,10 @@
+export { default as AverageLiteral } from './average-literal';
+export { default as CountLiteral } from './count-literal';
+export { default as DistinctLiteral } from './distinct-literal';
+export { default as FieldLiteral } from './field-literal';
+export { default as Literal } from './literal';
+export { default as LiteralBase } from './literal-base';
+export { default as LiteralFieldBase } from './literal-field-base';
+export { default as MaxLiteral } from './max-literal';
+export { default as MinLiteral } from './min-literal';
+export { default as SumLiteral } from './sum-literal';

package/lib/connection/literals/index.js

@@ -1,23 +1,25 @@
 'use strict';
 
-const LiteralBase      = require('./literal-base');
-const LiteralFieldBase = require('./literal-field-base');
-const Literal          = require('./literal');
-const AverageLiteral   = require('./average-literal');
-const CountLiteral     = require('./count-literal');
-const MaxLiteral       = require('./max-literal');
-const MinLiteral       = require('./min-literal');
-const DistinctLiteral  = require('./distinct-literal');
-const SumLiteral       = require('./sum-literal');
+const AverageLiteral    = require('./average-literal');
+const CountLiteral      = require('./count-literal');
+const DistinctLiteral   = require('./distinct-literal');
+const FieldLiteral      = require('./field-literal');
+const Literal           = require('./literal');
+const LiteralBase       = require('./literal-base');
+const LiteralFieldBase  = require('./literal-field-base');
+const MaxLiteral        = require('./max-literal');
+const MinLiteral        = require('./min-literal');
+const SumLiteral        = require('./sum-literal');
 
 module.exports = {
-  LiteralBase,
-  LiteralFieldBase,
-  Literal,
   AverageLiteral,
   CountLiteral,
+  DistinctLiteral,
+  FieldLiteral,
+  Literal,
+  LiteralBase,
+  LiteralFieldBase,
   MaxLiteral,
   MinLiteral,
-  DistinctLiteral,
   SumLiteral,
 };