objection 3.9.1 → 4.0.0-rc.2

package/lib/queryBuilder/operations/fieldExpressions.js

@@ -0,0 +1,122 @@
+import { ref } from '../ReferenceBuilder.js';
+import { isObject } from '../../utils/objectUtils.js';
+import { getFieldExpressionColumn } from '../../utils/parseFieldExpression.js';
+import { isKnexRaw, isKnexQueryBuilder } from '../../utils/knexUtils.js';
+import { getJsonDialect } from '../jsonDialects/index.js';
+import { ValidationErrorType } from '../../model/ValidationError.js';
+import { getQueryPropKeys } from '../../model/modelQueryProps.js';
+
+// Inserts and updates write whole values, so they can't write into json
+// columns with field expressions like `'meta:color'`. Keys with a ':' that don't
+// parse as field expressions are columns, as in the query properties.
+export function checkFieldExpressions(modelClass, model, operation) {
+  const keys = getFieldExpressionKeys(modelClass, [
+    ...Object.keys(model),
+    ...getQueryPropKeys(model),
+  ]);
+
+  if (keys.length > 0) {
+    throw modelClass.createValidationError({
+      type: ValidationErrorType.ModelValidation,
+      data: Object.fromEntries(
+        keys.map((key) => [
+          key,
+          [{ message: `field expressions can only be used in patch, not in ${operation}` }],
+        ]),
+      ),
+    });
+  }
+}
+
+// Field expressions only describe the writes into json columns, they aren't
+// properties of the models that the writes return:
+export function removeFieldExpressions(modelClass, model) {
+  for (const key of getFieldExpressionKeys(modelClass, Object.keys(model))) {
+    delete model[key];
+  }
+}
+
+export function convertFieldExpressionsToRaw(builder, json) {
+  const knex = builder.knex();
+  const dialect = getJsonDialect(knex);
+  const modelClass = builder.modelClass();
+  const declaredColumns = getDeclaredColumns(modelClass);
+  const convertedJson = {};
+
+  for (const key of Object.keys(json)) {
+    let val = json[key];
+
+    if (getFieldExpressionColumn(key, declaredColumns) !== null) {
+      // 'col:attr' : ref('other:lol') is transformed to
+      // "col" : raw(`jsonb_set("table"."col", '{attr}', to_jsonb("other"#>'{lol}'), true)`)
+      // on Postgres, with the column qualified, as it is ambiguous with
+      // `excluded` in merge().
+      dialect.checkSupport();
+
+      let parsed = ref(key);
+
+      // The field expression would be lost or produce invalid SQL next to a
+      // value for the whole json column. Report it with the property names:
+      if (Object.prototype.hasOwnProperty.call(json, parsed.column)) {
+        const property = modelClass.columnNameToPropertyName(parsed.column);
+        throw modelClass.createValidationError({
+          type: ValidationErrorType.ModelValidation,
+          data: {
+            [modelClass.columnNameToPropertyName(key)]: [
+              {
+                message: `can't be combined with a value for the json column '${property}'`,
+                keyword: null,
+                params: { property },
+              },
+            ],
+          },
+        });
+      }
+
+      let valuePlaceholder;
+
+      if (isKnexQueryBuilder(val) || isKnexRaw(val)) {
+        valuePlaceholder = dialect.toJson('?');
+      } else {
+        valuePlaceholder = dialect.json('?');
+        val = JSON.stringify(val);
+      }
+
+      convertedJson[parsed.column] = knex.raw(
+        dialect.set('??', parsed.parsedExpr.access, valuePlaceholder),
+        [convertedJson[parsed.column] || `${builder.tableRef()}.${parsed.column}`, val],
+      );
+    } else {
+      convertedJson[key] = val;
+    }
+  }
+
+  return convertedJson;
+}
+
+function getFieldExpressionKeys(modelClass, keys) {
+  const jsonSchema = modelClass.getJsonSchema();
+  return keys.filter((key) => getFieldExpressionColumn(key, jsonSchema?.properties) !== null);
+}
+
+const declaredColumnsByModelClass = new WeakMap();
+
+// The keys of `json` are column names, so map the properties with a ':' that the
+// schema declares to their columns, once per model class. Properties that only
+// the schema returned by `$beforeValidate()` declares aren't known here.
+export function getDeclaredColumns(modelClass) {
+  let declaredColumns = declaredColumnsByModelClass.get(modelClass);
+
+  if (!declaredColumns) {
+    const jsonSchema = modelClass.getJsonSchema();
+    const properties = jsonSchema && jsonSchema.properties;
+    declaredColumns = Object.fromEntries(
+      (isObject(properties) ? Object.keys(properties) : [])
+        .filter((key) => key.includes(':'))
+        .map((key) => [modelClass.propertyNameToColumnName(key), true]),
+    );
+    declaredColumnsByModelClass.set(modelClass, declaredColumns);
+  }
+
+  return declaredColumns;
+}

package/lib/queryBuilder/operations/jsonApi/WhereJsonHasOperation.js

@@ -0,0 +1,20 @@
+import { WhereJsonOperation } from './WhereJsonOperation.js';
+import { parseFieldExpression } from '../../../utils/parseFieldExpression.js';
+import { asArray, isString } from '../../../utils/objectUtils.js';
+
+// `whereJsonHasAny()`, `whereJsonHasAll()` and their variants.
+export class WhereJsonHasOperation extends WhereJsonOperation {
+  // @override
+  buildWhere(dialect, [fieldExpression, keys]) {
+    const { columnName, access } = parseFieldExpression(fieldExpression);
+    keys = asArray(keys);
+
+    if (keys.length === 0) {
+      throw new Error('At least one key to find is required.');
+    } else if (!keys.every(isString)) {
+      throw new Error('All keys to find must be strings.');
+    }
+
+    return dialect.hasKeys(columnName, access, keys, this.opt.all);
+  }
+}

package/lib/queryBuilder/operations/jsonApi/WhereJsonOperation.js

@@ -0,0 +1,44 @@
+import { ObjectionToKnexConvertingOperation } from '../ObjectionToKnexConvertingOperation.js';
+import { getJsonDialect } from '../../jsonDialects/index.js';
+import { parseFieldExpression } from '../../../utils/parseFieldExpression.js';
+import { isObject, isString } from '../../../utils/objectUtils.js';
+import { isKnexRaw, isKnexQueryBuilder } from '../../../utils/knexUtils.js';
+
+// `whereJsonSupersetOf()`, `whereJsonSubsetOf()` and their variants, and the
+// base class of the operations of the other `whereJson*()` methods.
+export class WhereJsonOperation extends ObjectionToKnexConvertingOperation {
+  onBuildKnex(knexBuilder, builder) {
+    const dialect = getJsonDialect(builder.knex());
+    dialect.checkSupport();
+    const [sql, bindings] = this.buildWhere(dialect, this.getKnexArgs(builder));
+
+    if (this.opt.bool === 'or') {
+      return knexBuilder.orWhereRaw(sql, bindings);
+    } else {
+      return knexBuilder.whereRaw(sql, bindings);
+    }
+  }
+
+  // @overridable
+  buildWhere(dialect, args) {
+    const [left, right] = args.map((arg) => toJsonOperand(dialect, arg));
+    const [sql, bindings] = this.opt.subset
+      ? dialect.subset(left, right)
+      : dialect.superset(left, right);
+    return [this.opt.not ? `not ${sql}` : sql, bindings];
+  }
+}
+
+function toJsonOperand(dialect, value) {
+  if (isString(value)) {
+    const { columnName, access } = parseFieldExpression(value);
+    return [dialect.jsonOperand(dialect.field('??', access)), [columnName]];
+  } else if (isKnexRaw(value) || isKnexQueryBuilder(value)) {
+    // ref(), val(), raw() and subqueries, already converted to knex by the operation.
+    return [dialect.jsonOperand('?'), [value]];
+  } else if (isObject(value)) {
+    return [dialect.jsonOperand(dialect.json('?')), [JSON.stringify(value)]];
+  } else {
+    throw new Error('Invalid right hand expression.');
+  }
+}

package/lib/queryBuilder/operations/jsonApi/WhereJsonTypeOperation.js

@@ -0,0 +1,14 @@
+import { WhereJsonOperation } from './WhereJsonOperation.js';
+import { parseFieldExpression } from '../../../utils/parseFieldExpression.js';
+
+// `whereJsonIsArray()`, `whereJsonNotArray()`, `whereJsonIsObject()`,
+// `whereJsonNotObject()` and their variants.
+export class WhereJsonTypeOperation extends WhereJsonOperation {
+  // @override
+  buildWhere(dialect, [fieldExpression]) {
+    const { columnName, access } = parseFieldExpression(fieldExpression);
+    const sql = dialect.isType('??', access, this.opt.type);
+    // Missing values and json `null` are neither arrays nor objects:
+    return [this.opt.not ? `not coalesce(${sql}, false)` : sql, [columnName]];
+  }
+}

package/lib/queryBuilder/operations/select/SelectOperation.js

@@ -1,8 +1,6 @@
-'use strict';
-
-const { flatten, isString, isPlainObject } = require('../../../utils/objectUtils');
-const { Selection } = require('./Selection');
-const { ObjectionToKnexConvertingOperation } = require('../ObjectionToKnexConvertingOperation');
+import { flatten, isString, isPlainObject } from '../../../utils/objectUtils.js';
+import { Selection } from './Selection.js';
+import { ObjectionToKnexConvertingOperation } from '../ObjectionToKnexConvertingOperation.js';
 
 const COUNT_REGEX = /count/i;
 const ALIAS_REGEX = /\s+as\s+/i;
@@ -18,13 +16,12 @@ const AGGREGATE_METHODS = new Set([
   'avgDistinct',
 ]);
 
-class SelectOperation extends ObjectionToKnexConvertingOperation {
+export class SelectOperation extends ObjectionToKnexConvertingOperation {
   constructor(name, opt) {
     super(name, opt);
     this.selections = [];
-    // The selections that aggregates select, by their aliases. `null` for
-    // non-aggregate operations.
-    this.aggregateSelections = AGGREGATE_METHODS.has(name) ? [] : null;
+    // Aggregates select their aliases, not the columns they're passed.
+    this.isAggregate = AGGREGATE_METHODS.has(name);
     // `distinctOn()` makes the rows distinct on its columns, it doesn't select them.
     this.isDistinctOn = name === 'distinctOn';
   }
@@ -40,7 +37,11 @@ class SelectOperation extends ObjectionToKnexConvertingOperation {
 
     const ret = super.onAdd(builder, selections);
 
-    if (!this.isDistinctOn) {
+    if (this.isAggregate) {
+      this.selections = getAggregateAliases(selections).map(
+        (alias) => new Selection(null, null, alias),
+      );
+    } else if (!this.isDistinctOn) {
       for (const selection of selections) {
         const selectionInstance = Selection.create(selection);
 
@@ -50,12 +51,6 @@ class SelectOperation extends ObjectionToKnexConvertingOperation {
       }
     }
 
-    if (this.aggregateSelections) {
-      this.aggregateSelections = getAggregateAliases(selections).map(
-        (alias) => new Selection(null, null, alias),
-      );
-    }
-
     return ret;
   }
 
@@ -82,7 +77,6 @@ class SelectOperation extends ObjectionToKnexConvertingOperation {
   clone() {
     const clone = super.clone();
     clone.selections = this.selections.slice();
-    clone.aggregateSelections = this.aggregateSelections && this.aggregateSelections.slice();
     return clone;
   }
 }
@@ -102,7 +96,3 @@ function getAggregateAliases([column, options]) {
     return [];
   }
 }
-
-module.exports = {
-  SelectOperation,
-};

package/lib/queryBuilder/operations/select/Selection.js

@@ -1,7 +1,5 @@
-'use strict';
-
-const { isString, isObject, isPlainObject } = require('../../../utils/objectUtils');
-const { isKnexQueryBuilder, isKnexRaw } = require('../../../utils/knexUtils');
+import { isString, isObject, isPlainObject } from '../../../utils/objectUtils.js';
+import { isKnexQueryBuilder, isKnexRaw } from '../../../utils/knexUtils.js';
 
 const ALIAS_REGEX = /\s+as\s+/i;
 
@@ -10,7 +8,7 @@ const ALIAS_REGEX = /\s+as\s+/i;
 const RAW_ALIAS_REGEX =
   /\s+as\s+(?:"([^"]+)"|`([^`]+)`|\[([^\]]+)\]|(\?\?)|:(\w+):|([a-z_][\w$]*))\s*$/i;
 
-class Selection {
+export class Selection {
   constructor(table, column, alias) {
     this.table = table;
     this.column = column;
@@ -97,10 +95,22 @@ Object.defineProperties(Selection.prototype, {
   },
 });
 
+// A selection without a column, of an aggregate, raw SQL or a subquery, selects
+// the column that its alias names, e.g. `max('ownerId as ownerId')` the join
+// column that the related models are assigned by. Selecting the column once
+// more would replace its value.
+export function hasAliasSelection(builder, alias) {
+  return builder
+    .findAllSelections()
+    .some(
+      (selection) => selection.column === null && isSameIdentifier(builder, selection.alias, alias),
+    );
+}
+
 // Identifiers that only differ in a way that knex's `wrapIdentifier` mapping
 // (for example `knexSnakeCaseMappers()`) cancels out are the same identifier:
 // `dataExtension` and `data_extension` both end up as `data_extension`.
-function isSameIdentifier(builder, identifier1, identifier2) {
+export function isSameIdentifier(builder, identifier1, identifier2) {
   if (identifier1 === identifier2) {
     return true;
   } else if (!identifier1 || !identifier2) {
@@ -112,7 +122,7 @@ function isSameIdentifier(builder, identifier1, identifier2) {
 
 // As in SQL, a table name without a schema refers to the table with a schema:
 // `persons` and `public.persons` are the same table.
-function isSameTable(builder, table1, table2) {
+export function isSameTable(builder, table1, table2) {
   if (isSameIdentifier(builder, table1, table2)) {
     return true;
   } else if (!table1 || !table2 || hasSchema(table1) === hasSchema(table2)) {
@@ -126,11 +136,11 @@ function hasSchema(table) {
   return table.includes('.');
 }
 
-function withoutSchema(table) {
+export function withoutSchema(table) {
   return table.slice(table.lastIndexOf('.') + 1);
 }
 
-function mapIdentifier(builder, identifier) {
+export function mapIdentifier(builder, identifier) {
   const knex = builder.unsafeKnex();
   const wrapIdentifier = knex && knex.client && knex.client.config.wrapIdentifier;
 
@@ -227,11 +237,3 @@ function createSelectionFromString(selection) {
 
   return new Selection(table, column, alias);
 }
-
-module.exports = {
-  Selection,
-  isSameIdentifier,
-  isSameTable,
-  mapIdentifier,
-  withoutSchema,
-};

package/lib/queryBuilder/operations/whereInComposite/WhereInCompositeMsSqlOperation.js

@@ -1,10 +1,8 @@
-'use strict';
+import { ObjectionToKnexConvertingOperation } from '../ObjectionToKnexConvertingOperation.js';
+import { flatten, zipObject, isString } from '../../../utils/objectUtils.js';
+import { getTempColumn } from '../../../utils/tmpColumnUtils.js';
 
-const { ObjectionToKnexConvertingOperation } = require('../ObjectionToKnexConvertingOperation');
-const { flatten, zipObject, isString } = require('../../../utils/objectUtils');
-const { getTempColumn } = require('../../../utils/tmpColumnUtils');
-
-class WhereInCompositeMsSqlOperation extends ObjectionToKnexConvertingOperation {
+export class WhereInCompositeMsSqlOperation extends ObjectionToKnexConvertingOperation {
   constructor(name, opt) {
     super(name, opt);
     this.prefix = this.opt.prefix || null;
@@ -119,7 +117,3 @@ function pickNonNull(values, output) {
 
   return output;
 }
-
-module.exports = {
-  WhereInCompositeMsSqlOperation,
-};

package/lib/queryBuilder/operations/whereInComposite/WhereInCompositeOperation.js

@@ -1,10 +1,8 @@
-'use strict';
+import { ObjectionToKnexConvertingOperation } from '../ObjectionToKnexConvertingOperation.js';
+import { isObject, asSingle } from '../../../utils/objectUtils.js';
+import { isKnexQueryBuilder } from '../../../utils/knexUtils.js';
 
-const { ObjectionToKnexConvertingOperation } = require('../ObjectionToKnexConvertingOperation');
-const { isObject, asSingle } = require('../../../utils/objectUtils');
-const { isKnexQueryBuilder } = require('../../../utils/knexUtils');
-
-class WhereInCompositeOperation extends ObjectionToKnexConvertingOperation {
+export class WhereInCompositeOperation extends ObjectionToKnexConvertingOperation {
   constructor(name, opt) {
     super(name, opt);
     this.prefix = this.opt.prefix || null;
@@ -98,7 +96,3 @@ function pickNonNull(values, output) {
 
   return output;
 }
-
-module.exports = {
-  WhereInCompositeOperation,
-};

package/lib/queryBuilder/operations/whereInComposite/WhereInCompositeSqliteOperation.js

@@ -1,10 +1,8 @@
-'use strict';
+import { ObjectionToKnexConvertingOperation } from '../ObjectionToKnexConvertingOperation.js';
+import { isKnexQueryBuilder } from '../../../utils/knexUtils.js';
+import { asSingle } from '../../../utils/objectUtils.js';
 
-const { ObjectionToKnexConvertingOperation } = require('../ObjectionToKnexConvertingOperation');
-const { isKnexQueryBuilder } = require('../../../utils/knexUtils');
-const { asSingle } = require('../../../utils/objectUtils');
-
-class WhereInCompositeSqliteOperation extends ObjectionToKnexConvertingOperation {
+export class WhereInCompositeSqliteOperation extends ObjectionToKnexConvertingOperation {
   constructor(name, opt) {
     super(name, opt);
     this.prefix = this.opt.prefix || null;
@@ -102,7 +100,3 @@ function pickNonNull(values, output) {
 
   return output;
 }
-
-module.exports = {
-  WhereInCompositeSqliteOperation,
-};

package/lib/queryBuilder/operations/windowOrder.js

@@ -0,0 +1,56 @@
+import { isString } from '../../utils/objectUtils.js';
+import { isKnexRaw } from '../../utils/knexUtils.js';
+import { Selection, isSameTable } from './select/Selection.js';
+
+// Without underscores, so that column name mappers don't change it.
+export const rowNumberColumn = 'objectiontmprownum';
+
+// Convert the `orderBy()` and `orderByRaw()` calls of the query to the order
+// of knex's window functions, which refer to the query's table by `table`.
+// Bare columns are qualified with it too, as the window can be in a query that
+// joins tables with the same columns.
+export function getWindowOrder(builder, knex, table) {
+  const order = [];
+  const tableRef = builder.tableRef();
+
+  const getAliasedColumn = (column) => {
+    const selection = isString(column) && Selection.create(column);
+    return selection && (!selection.table || isSameTable(builder, selection.table, tableRef))
+      ? `${table}.${selection.column}`
+      : column;
+  };
+
+  builder.forEachOperation(builder.constructor.OrderBySelector, (op) => {
+    const args = op.getKnexArgs(builder);
+
+    if (op.name === 'orderByRaw') {
+      const [sql, bindings] = args;
+      order.push({ column: isKnexRaw(sql) ? sql : knex.raw(sql, bindings) });
+    } else {
+      const [column, direction, nulls] = args;
+      const items = Array.isArray(column)
+        ? column.map((item) => (isString(item) ? { column: item } : item))
+        : [{ column, order: direction, nulls }];
+
+      for (const item of items) {
+        const aliasedColumn = getAliasedColumn(item.column);
+
+        if (item.nulls) {
+          // Not all databases support `nulls first` and `nulls last`:
+          order.push({
+            column: knex.raw('(case when ? is null then 0 else 1 end)', [
+              isString(aliasedColumn) ? knex.ref(aliasedColumn) : aliasedColumn,
+            ]),
+            order: item.nulls === 'first' ? 'asc' : 'desc',
+          });
+        }
+
+        // Unlike in `orderBy()`, knex adds the direction to the window as it is:
+        order.push({ column: aliasedColumn, order: /^desc$/i.test(item.order) ? 'desc' : 'asc' });
+      }
+    }
+  });
+
+  // SQL Server requires an order in the window function:
+  return order.length ? order : [{ column: knex.raw('(select null)') }];
+}

package/lib/queryBuilder/parsers/jsonFieldExpressionParser.js

@@ -2,8 +2,6 @@
 //
 // https://peggyjs.org/
 
-'use strict';
-
 class peg$SyntaxError extends SyntaxError {
   constructor(message, expected, found, location) {
     super(message);
@@ -987,8 +985,6 @@ function peg$parse(input, options) {
   }
 }
 
-module.exports = {
-  StartRules: ['start'],
-  SyntaxError: peg$SyntaxError,
-  parse: peg$parse,
-};
+const peg$allowedStartRules = ['start'];
+
+export { peg$allowedStartRules as StartRules, peg$SyntaxError as SyntaxError, peg$parse as parse };

package/lib/queryBuilder/parsers/relationExpressionParser.js

@@ -2,10 +2,6 @@
 //
 // https://peggyjs.org/
 
-'use strict';
-
-const { warnOnce } = require('../../utils/warnings');
-
 class peg$SyntaxError extends SyntaxError {
   constructor(message, expected, found, location) {
     super(message);
@@ -216,12 +212,11 @@ function peg$parse(input, options) {
   function peg$f0(expr) {
     const node = newNode();
 
-    if (expr.$name === '*') {
+    if (expr.$relation === '*') {
+      assertPlainToken(expr);
       node.$allRecursive = true;
     } else {
-      assertDuplicateRelation(node, expr);
-      node[expr.$name] = expr;
-      node.$childNames.push(expr.$name);
+      addChild(node, expr);
     }
 
     return node;
@@ -229,11 +224,7 @@ function peg$parse(input, options) {
   function peg$f1(list) {
     const node = newNode();
 
-    list.forEach((expr) => {
-      assertDuplicateRelation(node, expr);
-      node[expr.$name] = expr;
-      node.$childNames.push(expr.$name);
-    });
+    list.forEach((expr) => addChild(node, expr));
 
     return node;
   }
@@ -244,11 +235,7 @@ function peg$parse(input, options) {
     node.$relation = name;
     node.$modify = args || [];
 
-    list.forEach((expr) => {
-      assertDuplicateRelation(node, expr);
-      node[expr.$name] = expr;
-      node.$childNames.push(expr.$name);
-    });
+    list.forEach((expr) => addChild(node, expr));
 
     return node;
   }
@@ -260,20 +247,14 @@ function peg$parse(input, options) {
     node.$modify = args || [];
 
     if (expr) {
-      const match = /^\^(\d*)$/.exec(expr.$name);
-
-      if (match) {
-        if (match[1]) {
-          node.$recursive = parseInt(match[1], 10);
-        } else {
-          node.$recursive = true;
-        }
-      } else if (expr.$name === '*') {
+      if (expr.$relation === '*') {
+        assertPlainToken(expr);
         node.$allRecursive = true;
+      } else if (isToken(expr.$relation)) {
+        assertPlainToken(expr);
+        node.$recursive = expr.$relation === '^' ? true : parseInt(expr.$relation.slice(1), 10);
       } else {
-        assertDuplicateRelation(node, expr);
-        node[expr.$name] = expr;
-        node.$childNames.push(expr.$name);
+        addChild(node, expr);
       }
     }
 
@@ -944,19 +925,39 @@ function peg$parse(input, options) {
     return s0;
   }
 
-  function assertDuplicateRelation(node, expr) {
+  function addChild(node, expr) {
+    if (isToken(expr.$relation)) {
+      throwMisplacedToken(expr.$relation);
+    }
+
     if (Object.prototype.hasOwnProperty.call(node, expr.$name)) {
-      warnOnce(
-        `Duplicate relation "${expr.$name}" in a relation expression, only the last one is used. Use "a.[b, c]" instead of "[a.b, a.c]". This will throw an error in objection 4.0.`,
-      );
+      const err = new Error();
+      err.duplicateRelationName = expr.$name;
+      throw err;
+    }
 
-      // Throws in objection 4.0, see ditojs/objection#53.
-      // const err = new Error();
-      // err.duplicateRelationName = expr.$name;
-      // throw err;
+    node[expr.$name] = expr;
+    node.$childNames.push(expr.$name);
+  }
+
+  // `*` and `^` end a relation path, without modifiers, aliases or relations
+  // after them.
+  function isToken(name) {
+    return /^(\*|\^\d*)$/.test(name);
+  }
+
+  function assertPlainToken(expr) {
+    if (expr.$childNames.length > 0 || expr.$modify.length > 0 || expr.$name !== expr.$relation) {
+      throwMisplacedToken(expr.$relation);
     }
   }
 
+  function throwMisplacedToken(token) {
+    const err = new Error();
+    err.misplacedToken = token;
+    throw err;
+  }
+
   function newNode() {
     return {
       $name: null,
@@ -1002,8 +1003,6 @@ function peg$parse(input, options) {
   }
 }
 
-module.exports = {
-  StartRules: ['start'],
-  SyntaxError: peg$SyntaxError,
-  parse: peg$parse,
-};
+const peg$allowedStartRules = ['start'];
+
+export { peg$allowedStartRules as StartRules, peg$SyntaxError as SyntaxError, peg$parse as parse };