json-rest-api 1.0.14 → 1.0.15

package/plugins/core/lib/anyapi/query/anyapi-query-adapter.js

@@ -1,4 +1,4 @@
-import { resolveFieldInfo } from '../utils/descriptor-helpers.js';
+import { resolveFieldInfo } from '../utils/descriptor-helpers.js'
 
 const JOIN_METHODS = new Set([
   'join',
@@ -9,7 +9,7 @@ const JOIN_METHODS = new Set([
   'rightOuterJoin',
   'outerJoin',
   'crossJoin',
-]);
+])
 
 const JOIN_ON_METHODS = new Set([
   'on',
@@ -18,28 +18,28 @@ const JOIN_ON_METHODS = new Set([
   'onVal',
   'andOnVal',
   'orOnVal',
-]);
+])
 
 const JOIN_ON_IN_METHODS = new Set([
   'onIn',
   'orOnIn',
   'onNotIn',
   'orOnNotIn',
-]);
+])
 
 const JOIN_ON_NULL_METHODS = new Set([
   'onNull',
   'orOnNull',
   'onNotNull',
   'orOnNotNull',
-]);
+])
 
 const JOIN_ON_BETWEEN_METHODS = new Set([
   'onBetween',
   'orOnBetween',
   'onNotBetween',
   'orOnNotBetween',
-]);
+])
 
 const WHERE_METHODS = new Set([
   'where',
@@ -50,26 +50,26 @@ const WHERE_METHODS = new Set([
   'orWhereNot',
   'having',
   'orHaving',
-]);
+])
 
 const WHERE_IN_METHODS = new Set([
   'whereIn',
   'orWhereIn',
   'whereNotIn',
   'orWhereNotIn',
-]);
+])
 
-const BETWEEN_METHODS = new Set(['whereBetween', 'orWhereBetween', 'whereNotBetween', 'orWhereNotBetween']);
+const BETWEEN_METHODS = new Set(['whereBetween', 'orWhereBetween', 'whereNotBetween', 'orWhereNotBetween'])
 
-const NULL_METHODS = new Set(['whereNull', 'orWhereNull', 'whereNotNull', 'orWhereNotNull']);
+const NULL_METHODS = new Set(['whereNull', 'orWhereNull', 'whereNotNull', 'orWhereNotNull'])
 
-const ORDER_METHODS = new Set(['orderBy', 'orderByRaw']);
+const ORDER_METHODS = new Set(['orderBy', 'orderByRaw'])
 
-const GROUP_METHODS = new Set(['groupBy', 'groupByRaw']);
+const GROUP_METHODS = new Set(['groupBy', 'groupByRaw'])
 
-const SELECT_METHODS = new Set(['select', 'columns', 'distinct']);
+const SELECT_METHODS = new Set(['select', 'columns', 'distinct'])
 
-const AGGREGATE_METHODS = new Set(['count', 'min', 'max', 'sum', 'avg']);
+const AGGREGATE_METHODS = new Set(['count', 'min', 'max', 'sum', 'avg'])
 
 const CALLBACK_FIRST_METHODS = new Set([
   'where',
@@ -77,10 +77,10 @@ const CALLBACK_FIRST_METHODS = new Set([
   'orWhere',
   'having',
   'orHaving',
-]);
+])
 
-const isFunction = (value) => typeof value === 'function';
-const isObject = (value) => value && typeof value === 'object' && !Array.isArray(value);
+const isFunction = (value) => typeof value === 'function'
+const isObject = (value) => value && typeof value === 'object' && !Array.isArray(value)
 
 const SQL_OPERATORS = new Set([
   '=',
@@ -98,111 +98,111 @@ const SQL_OPERATORS = new Set([
   'is not',
   'is null',
   'is not null',
-]);
+])
 
 const parseTableExpression = (expression) => {
   if (expression && typeof expression === 'object' && !Array.isArray(expression)) {
-    const [alias, tableName] = Object.entries(expression)[0] || [];
+    const [alias, tableName] = Object.entries(expression)[0] || []
     if (!alias) {
-      return { original: expression };
+      return { original: expression }
     }
-    return { alias, tableName, original: expression };
+    return { alias, tableName, original: expression }
   }
 
   if (typeof expression !== 'string') {
-    return { original: expression };
+    return { original: expression }
   }
 
-  const raw = expression.trim();
+  const raw = expression.trim()
   if (raw === '') {
-    return { original: expression };
+    return { original: expression }
   }
 
-  const asMatch = raw.split(/\s+as\s+/i);
+  const asMatch = raw.split(/\s+as\s+/i)
   if (asMatch.length === 2) {
-    return { tableName: asMatch[0].trim(), alias: asMatch[1].trim(), original: expression };
+    return { tableName: asMatch[0].trim(), alias: asMatch[1].trim(), original: expression }
   }
 
-  const parts = raw.split(/\s+/);
+  const parts = raw.split(/\s+/)
   if (parts.length === 2) {
-    return { tableName: parts[0].trim(), alias: parts[1].trim(), original: expression };
+    return { tableName: parts[0].trim(), alias: parts[1].trim(), original: expression }
   }
 
-  return { tableName: raw, alias: raw, original: expression };
-};
+  return { tableName: raw, alias: raw, original: expression }
+}
 
 const translateObjectKeys = (adapter, obj) => {
-  const result = {};
+  const result = {}
   for (const [key, value] of Object.entries(obj)) {
-    result[adapter.translateColumn(key)] = value;
+    result[adapter.translateColumn(key)] = value
   }
-  return result;
-};
+  return result
+}
 
 const translateJoinObject = (adapter, obj) => {
-  const result = {};
+  const result = {}
   for (const [lhs, rhs] of Object.entries(obj)) {
-    const translatedKey = typeof lhs === 'string' ? adapter.translateColumn(lhs) : lhs;
-    const translatedValue = typeof rhs === 'string' ? adapter.translateColumn(rhs) : rhs;
-    result[translatedKey] = translatedValue;
+    const translatedKey = typeof lhs === 'string' ? adapter.translateColumn(lhs) : lhs
+    const translatedValue = typeof rhs === 'string' ? adapter.translateColumn(rhs) : rhs
+    result[translatedKey] = translatedValue
   }
-  return result;
-};
+  return result
+}
 
 const maybeWrapCallback = (adapter, callback) => {
-  if (!isFunction(callback)) return callback;
-  return function wrappedCallback(...args) {
-    return callback.apply(adapter.proxy, args);
-  };
-};
+  if (!isFunction(callback)) return callback
+  return function wrappedCallback (...args) {
+    return callback.apply(adapter.proxy, args)
+  }
+}
 
-const isRaw = (value) => Boolean(value && typeof value === 'object' && typeof value.toSQL === 'function' && value.toSQL().method);
+const isRaw = (value) => Boolean(value && typeof value === 'object' && typeof value.toSQL === 'function' && value.toSQL().method)
 
-const ensureArray = (value) => (Array.isArray(value) ? value : [value]);
+const ensureArray = (value) => (Array.isArray(value) ? value : [value])
 
-export async function preloadRelatedDescriptors({ registry, descriptor }) {
-  const visited = new Map();
-  const queue = [descriptor.resource];
-  visited.set(descriptor.resource, descriptor);
+export async function preloadRelatedDescriptors ({ registry, descriptor }) {
+  const visited = new Map()
+  const queue = [descriptor.resource]
+  visited.set(descriptor.resource, descriptor)
 
   while (queue.length > 0) {
-    const resource = queue.pop();
-    const current = visited.get(resource);
-    if (!current) continue;
+    const resource = queue.pop()
+    const current = visited.get(resource)
+    if (!current) continue
 
-    const relatedTargets = new Set();
+    const relatedTargets = new Set()
 
     Object.values(current.belongsTo || {}).forEach((info) => {
-      if (info?.target) relatedTargets.add(info.target);
-    });
+      if (info?.target) relatedTargets.add(info.target)
+    })
 
     Object.values(current.relationships || {}).forEach((info) => {
-      if (info?.target) relatedTargets.add(info.target);
-    });
+      if (info?.target) relatedTargets.add(info.target)
+    })
 
     Object.values(current.manyToMany || {}).forEach((info) => {
-      if (info?.target) relatedTargets.add(info.target);
-      if (info?.through) relatedTargets.add(info.through);
-    });
+      if (info?.target) relatedTargets.add(info.target)
+      if (info?.through) relatedTargets.add(info.through)
+    })
 
     Object.values(current.polymorphicBelongsTo || {}).forEach((info) => {
-      ensureArray(info?.types || []).forEach((type) => relatedTargets.add(type));
-    });
+      ensureArray(info?.types || []).forEach((type) => relatedTargets.add(type))
+    })
 
     for (const target of relatedTargets) {
-      if (!target || visited.has(target)) continue;
-      const nextDescriptor = await registry.getDescriptor(current.tenant, target);
-      if (!nextDescriptor) continue;
-      visited.set(target, nextDescriptor);
-      queue.push(target);
+      if (!target || visited.has(target)) continue
+      const nextDescriptor = await registry.getDescriptor(current.tenant, target)
+      if (!nextDescriptor) continue
+      visited.set(target, nextDescriptor)
+      queue.push(target)
     }
   }
 
-  return visited;
+  return visited
 }
 
 export class AnyapiQueryAdapter {
-  constructor({
+  constructor ({
     descriptor,
     db,
     registry,
@@ -211,437 +211,437 @@ export class AnyapiQueryAdapter {
     tableNameToResource,
     log,
   }) {
-    this.descriptor = descriptor;
-    this.db = db;
-    this.registry = registry;
-    this.descriptorsMap = descriptorsMap;
-    this.resourceToTableName = resourceToTableName || new Map();
-    this.tableNameToResource = tableNameToResource || new Map();
-    this.log = log || console;
-
-    this.primaryAlias = this.resourceToTableName.get(descriptor.resource) || descriptor.resource;
-    this.aliasDescriptors = new Map();
-    this.aliasDescriptors.set(this.primaryAlias, descriptor);
-
-    this.aliasDescriptors.set(descriptor.resource, descriptor);
-    this.aliasActualNames = new Map();
-    this.aliasActualNames.set(this.primaryAlias, this.primaryAlias);
-    this.aliasActualNames.set(descriptor.resource, this.primaryAlias);
-
-    const physicalTableName = this.resourceToTableName.get(descriptor.resource);
+    this.descriptor = descriptor
+    this.db = db
+    this.registry = registry
+    this.descriptorsMap = descriptorsMap
+    this.resourceToTableName = resourceToTableName || new Map()
+    this.tableNameToResource = tableNameToResource || new Map()
+    this.log = log || console
+
+    this.primaryAlias = this.resourceToTableName.get(descriptor.resource) || descriptor.resource
+    this.aliasDescriptors = new Map()
+    this.aliasDescriptors.set(this.primaryAlias, descriptor)
+
+    this.aliasDescriptors.set(descriptor.resource, descriptor)
+    this.aliasActualNames = new Map()
+    this.aliasActualNames.set(this.primaryAlias, this.primaryAlias)
+    this.aliasActualNames.set(descriptor.resource, this.primaryAlias)
+
+    const physicalTableName = this.resourceToTableName.get(descriptor.resource)
     if (physicalTableName) {
-      this.aliasDescriptors.set(physicalTableName, descriptor);
-      this.aliasActualNames.set(physicalTableName, this.primaryAlias);
+      this.aliasDescriptors.set(physicalTableName, descriptor)
+      this.aliasActualNames.set(physicalTableName, this.primaryAlias)
     }
 
-    this.builders = new WeakMap();
+    this.builders = new WeakMap()
 
     this.builder = db({ [this.primaryAlias]: descriptor.canonical.tableName })
       .where(`${this.primaryAlias}.${descriptor.canonical.tenantColumn}`, descriptor.tenant)
-      .where(`${this.primaryAlias}.${descriptor.canonical.resourceColumn}`, descriptor.resource);
+      .where(`${this.primaryAlias}.${descriptor.canonical.resourceColumn}`, descriptor.resource)
 
-    this.proxy = this.#createProxy(this.builder);
+    this.proxy = this.#createProxy(this.builder)
   }
 
-  get tableAlias() {
-    return this.primaryAlias;
+  get tableAlias () {
+    return this.primaryAlias
   }
 
-  get query() {
-    return this.proxy;
+  get query () {
+    return this.proxy
   }
 
-  translateColumn(reference) {
+  translateColumn (reference) {
     if (typeof reference !== 'string') {
-      return reference;
+      return reference
     }
 
-    const trimmed = reference.trim();
+    const trimmed = reference.trim()
     if (trimmed === '*' || trimmed === '') {
-      return reference;
+      return reference
     }
 
-    const parts = trimmed.split('.');
-    let requestedAlias;
-    let field;
+    const parts = trimmed.split('.')
+    let requestedAlias
+    let field
 
     if (parts.length === 1) {
-      requestedAlias = this.primaryAlias;
-      field = parts[0];
+      requestedAlias = this.primaryAlias
+      field = parts[0]
     } else {
-      requestedAlias = parts.shift();
-      field = parts.join('.');
+      requestedAlias = parts.shift()
+      field = parts.join('.')
     }
 
     if (!field) {
-      return reference;
+      return reference
     }
 
-    let descriptor = this.aliasDescriptors.get(requestedAlias);
+    let descriptor = this.aliasDescriptors.get(requestedAlias)
     if (!descriptor) {
-      const resource = this.tableNameToResource.get(requestedAlias) || requestedAlias;
-      descriptor = this.descriptorsMap.get(resource);
+      const resource = this.tableNameToResource.get(requestedAlias) || requestedAlias
+      descriptor = this.descriptorsMap.get(resource)
       if (descriptor) {
-        this.aliasDescriptors.set(requestedAlias, descriptor);
-        const actualAlias = this.resourceToTableName.get(resource) || resource;
-        this.aliasActualNames.set(requestedAlias, actualAlias);
+        this.aliasDescriptors.set(requestedAlias, descriptor)
+        const actualAlias = this.resourceToTableName.get(resource) || resource
+        this.aliasActualNames.set(requestedAlias, actualAlias)
       }
     }
 
     if (!descriptor) {
-      return reference;
+      return reference
     }
 
-    const info = resolveFieldInfo(descriptor, field);
+    const info = resolveFieldInfo(descriptor, field)
     if (!info?.column) {
-      return reference;
+      return reference
     }
 
-    const actualAlias = this.aliasActualNames.get(requestedAlias)
-      || this.resourceToTableName.get(descriptor.resource)
-      || descriptor.resource;
+    const actualAlias = this.aliasActualNames.get(requestedAlias) ||
+      this.resourceToTableName.get(descriptor.resource) ||
+      descriptor.resource
 
-    return `${actualAlias}.${info.column}`;
+    return `${actualAlias}.${info.column}`
   }
 
-  translateColumns(columns) {
+  translateColumns (columns) {
     if (Array.isArray(columns)) {
-      return columns.map((column) => this.translateColumn(column));
+      return columns.map((column) => this.translateColumn(column))
     }
-    return this.translateColumn(columns);
+    return this.translateColumn(columns)
   }
 
-  registerAlias(alias, descriptor) {
-    if (!alias || !descriptor) return;
-    this.aliasDescriptors.set(alias, descriptor);
-    this.aliasActualNames.set(alias, alias);
+  registerAlias (alias, descriptor) {
+    if (!alias || !descriptor) return
+    this.aliasDescriptors.set(alias, descriptor)
+    this.aliasActualNames.set(alias, alias)
   }
 
-  #translateWhereArgs(method, args) {
-    if (args.length === 0) return args;
-    const [first, ...rest] = args;
+  #translateWhereArgs (method, args) {
+    if (args.length === 0) return args
+    const [first, ...rest] = args
 
     if (isFunction(first)) {
-      return [maybeWrapCallback(this, first), ...rest];
+      return [maybeWrapCallback(this, first), ...rest]
     }
 
     if (isObject(first) && !isRaw(first)) {
-      return [translateObjectKeys(this, first), ...rest];
+      return [translateObjectKeys(this, first), ...rest]
     }
 
     if (Array.isArray(first)) {
-      return [first.map((item) => (typeof item === 'string' ? this.translateColumn(item) : item)), ...rest];
+      return [first.map((item) => (typeof item === 'string' ? this.translateColumn(item) : item)), ...rest]
     }
 
-    const translatedFirst = this.translateColumn(first);
+    const translatedFirst = this.translateColumn(first)
 
     if (rest.length > 0 && isFunction(rest[rest.length - 1])) {
-      const newRest = [...rest];
-      newRest[newRest.length - 1] = maybeWrapCallback(this, rest[rest.length - 1]);
-      return [translatedFirst, ...newRest];
+      const newRest = [...rest]
+      newRest[newRest.length - 1] = maybeWrapCallback(this, rest[rest.length - 1])
+      return [translatedFirst, ...newRest]
     }
 
-    return [translatedFirst, ...rest];
+    return [translatedFirst, ...rest]
   }
 
-  #translateWhereInArgs(args) {
-    if (args.length === 0) return args;
-    const [column, values, ...rest] = args;
-    const translatedColumn = this.translateColumn(column);
+  #translateWhereInArgs (args) {
+    if (args.length === 0) return args
+    const [column, values, ...rest] = args
+    const translatedColumn = this.translateColumn(column)
 
     if (isFunction(values)) {
-      return [translatedColumn, maybeWrapCallback(this, values), ...rest];
+      return [translatedColumn, maybeWrapCallback(this, values), ...rest]
     }
 
-    return [translatedColumn, values, ...rest];
+    return [translatedColumn, values, ...rest]
   }
 
-  #translateBetweenArgs(args) {
-    if (args.length === 0) return args;
-    const [column, range, ...rest] = args;
-    return [this.translateColumn(column), range, ...rest];
+  #translateBetweenArgs (args) {
+    if (args.length === 0) return args
+    const [column, range, ...rest] = args
+    return [this.translateColumn(column), range, ...rest]
   }
 
-  #translateNullArgs(args) {
-    if (args.length === 0) return args;
-    const [column, ...rest] = args;
-    return [this.translateColumn(column), ...rest];
+  #translateNullArgs (args) {
+    if (args.length === 0) return args
+    const [column, ...rest] = args
+    return [this.translateColumn(column), ...rest]
   }
 
-  #translateOrderArgs(method, args) {
-    if (args.length === 0) return args;
+  #translateOrderArgs (method, args) {
+    if (args.length === 0) return args
 
     if (method === 'orderByRaw') {
-      return args;
+      return args
     }
 
-    const [column, direction, ...rest] = args;
+    const [column, direction, ...rest] = args
 
     if (Array.isArray(column)) {
       return [column.map((entry) => {
         if (typeof entry === 'string') {
-          return this.translateColumn(entry);
+          return this.translateColumn(entry)
         }
         if (isObject(entry)) {
-          const [col, dir] = Object.entries(entry)[0] || [];
-          if (!col) return entry;
-          return { [this.translateColumn(col)]: dir };
+          const [col, dir] = Object.entries(entry)[0] || []
+          if (!col) return entry
+          return { [this.translateColumn(col)]: dir }
         }
-        return entry;
-      }), direction, ...rest];
+        return entry
+      }), direction, ...rest]
     }
 
     if (isObject(column) && column.column) {
-      return [{ ...column, column: this.translateColumn(column.column) }, direction, ...rest];
+      return [{ ...column, column: this.translateColumn(column.column) }, direction, ...rest]
     }
 
-    return [this.translateColumn(column), direction, ...rest];
+    return [this.translateColumn(column), direction, ...rest]
   }
 
-  #translateGroupArgs(args) {
-    if (args.length === 0) return args;
-    const [first, ...rest] = args;
+  #translateGroupArgs (args) {
+    if (args.length === 0) return args
+    const [first, ...rest] = args
     if (Array.isArray(first)) {
-      return [first.map((entry) => (typeof entry === 'string' ? this.translateColumn(entry) : entry)), ...rest];
+      return [first.map((entry) => (typeof entry === 'string' ? this.translateColumn(entry) : entry)), ...rest]
     }
-    return [this.translateColumn(first), ...rest];
+    return [this.translateColumn(first), ...rest]
   }
 
-  #translateSelectArgs(args) {
-    if (args.length === 0) return args;
-    const [first, ...rest] = args;
+  #translateSelectArgs (args) {
+    if (args.length === 0) return args
+    const [first, ...rest] = args
 
     if (Array.isArray(first)) {
-      return [first.map((entry) => (typeof entry === 'string' ? this.translateColumn(entry) : entry)), ...rest];
+      return [first.map((entry) => (typeof entry === 'string' ? this.translateColumn(entry) : entry)), ...rest]
     }
 
     if (typeof first === 'string') {
-      return [this.translateColumn(first), ...rest];
+      return [this.translateColumn(first), ...rest]
     }
 
-    return [first, ...rest];
+    return [first, ...rest]
   }
 
-  #translateAggregateArgs(args) {
-    if (args.length === 0) return args;
-    const [column, options] = args;
+  #translateAggregateArgs (args) {
+    if (args.length === 0) return args
+    const [column, options] = args
     if (Array.isArray(column)) {
-      return [column.map((entry) => (typeof entry === 'string' ? this.translateColumn(entry) : entry)), options];
+      return [column.map((entry) => (typeof entry === 'string' ? this.translateColumn(entry) : entry)), options]
     }
     if (typeof column === 'string') {
-      return [this.translateColumn(column), options];
+      return [this.translateColumn(column), options]
     }
-    return args;
+    return args
   }
 
-  #translateOnArgs(args) {
-    if (args.length === 0) return args;
-    const [first, ...rest] = args;
+  #translateOnArgs (args) {
+    if (args.length === 0) return args
+    const [first, ...rest] = args
 
     if (isFunction(first)) {
-      return [maybeWrapCallback(this, first), ...rest];
+      return [maybeWrapCallback(this, first), ...rest]
     }
 
     if (isObject(first) && !isRaw(first)) {
-      return [translateJoinObject(this, first), ...rest];
+      return [translateJoinObject(this, first), ...rest]
     }
 
-    const translatedFirst = typeof first === 'string' ? this.translateColumn(first) : first;
+    const translatedFirst = typeof first === 'string' ? this.translateColumn(first) : first
 
     if (rest.length === 0) {
-      return [translatedFirst];
+      return [translatedFirst]
     }
 
     const translatedRest = rest.map((value, index) => {
       if (isFunction(value)) {
-        return maybeWrapCallback(this, value);
+        return maybeWrapCallback(this, value)
       }
       if (typeof value !== 'string') {
-        return value;
+        return value
       }
-      const lower = value.toLowerCase();
+      const lower = value.toLowerCase()
       if (SQL_OPERATORS.has(lower)) {
-        return value;
+        return value
       }
-      return this.translateColumn(value);
-    });
+      return this.translateColumn(value)
+    })
 
-    return [translatedFirst, ...translatedRest];
+    return [translatedFirst, ...translatedRest]
   }
 
-  #translateOnInArgs(args) {
-    if (args.length === 0) return args;
-    const [column, values, ...rest] = args;
-    const translatedColumn = typeof column === 'string' ? this.translateColumn(column) : column;
+  #translateOnInArgs (args) {
+    if (args.length === 0) return args
+    const [column, values, ...rest] = args
+    const translatedColumn = typeof column === 'string' ? this.translateColumn(column) : column
 
     if (isFunction(values)) {
-      return [translatedColumn, maybeWrapCallback(this, values), ...rest];
+      return [translatedColumn, maybeWrapCallback(this, values), ...rest]
     }
 
-    return [translatedColumn, values, ...rest];
+    return [translatedColumn, values, ...rest]
   }
 
-  #translateOnBetweenArgs(args) {
-    if (args.length === 0) return args;
-    const [column, range, ...rest] = args;
-    return [typeof column === 'string' ? this.translateColumn(column) : column, range, ...rest];
+  #translateOnBetweenArgs (args) {
+    if (args.length === 0) return args
+    const [column, range, ...rest] = args
+    return [typeof column === 'string' ? this.translateColumn(column) : column, range, ...rest]
   }
 
-  #translateOnNullArgs(args) {
-    if (args.length === 0) return args;
-    const [column, ...rest] = args;
-    return [typeof column === 'string' ? this.translateColumn(column) : column, ...rest];
+  #translateOnNullArgs (args) {
+    if (args.length === 0) return args
+    const [column, ...rest] = args
+    return [typeof column === 'string' ? this.translateColumn(column) : column, ...rest]
   }
 
-  #addResourceConstraints(joinClause, alias, descriptor) {
-    joinClause.on(`${alias}.${descriptor.canonical.tenantColumn}`, this.db.raw('?', [descriptor.tenant]));
-    joinClause.andOn(`${alias}.${descriptor.canonical.resourceColumn}`, this.db.raw('?', [descriptor.resource]));
+  #addResourceConstraints (joinClause, alias, descriptor) {
+    joinClause.on(`${alias}.${descriptor.canonical.tenantColumn}`, this.db.raw('?', [descriptor.tenant]))
+    joinClause.andOn(`${alias}.${descriptor.canonical.resourceColumn}`, this.db.raw('?', [descriptor.resource]))
   }
 
-  #createJoinProxy(joinClause) {
-    const adapter = this;
+  #createJoinProxy (joinClause) {
+    const adapter = this
     const handler = {
-      get(target, prop, receiver) {
-        const original = target[prop];
+      get (target, prop, receiver) {
+        const original = target[prop]
         if (typeof original !== 'function') {
-          return Reflect.get(target, prop, receiver);
+          return Reflect.get(target, prop, receiver)
         }
         return (...args) => {
-          let translatedArgs = args;
+          let translatedArgs = args
 
           if (WHERE_METHODS.has(prop)) {
-            translatedArgs = adapter.#translateWhereArgs(prop, args);
+            translatedArgs = adapter.#translateWhereArgs(prop, args)
           } else if (WHERE_IN_METHODS.has(prop)) {
-            translatedArgs = adapter.#translateWhereInArgs(args);
+            translatedArgs = adapter.#translateWhereInArgs(args)
           } else if (BETWEEN_METHODS.has(prop)) {
-            translatedArgs = adapter.#translateBetweenArgs(args);
+            translatedArgs = adapter.#translateBetweenArgs(args)
           } else if (NULL_METHODS.has(prop)) {
-            translatedArgs = adapter.#translateNullArgs(args);
+            translatedArgs = adapter.#translateNullArgs(args)
           } else if (JOIN_ON_METHODS.has(prop)) {
-            translatedArgs = adapter.#translateOnArgs(args);
+            translatedArgs = adapter.#translateOnArgs(args)
           } else if (JOIN_ON_IN_METHODS.has(prop)) {
-            translatedArgs = adapter.#translateOnInArgs(args);
+            translatedArgs = adapter.#translateOnInArgs(args)
           } else if (JOIN_ON_BETWEEN_METHODS.has(prop)) {
-            translatedArgs = adapter.#translateOnBetweenArgs(args);
+            translatedArgs = adapter.#translateOnBetweenArgs(args)
           } else if (JOIN_ON_NULL_METHODS.has(prop)) {
-            translatedArgs = adapter.#translateOnNullArgs(args);
+            translatedArgs = adapter.#translateOnNullArgs(args)
           }
 
-          const result = original.apply(target, translatedArgs);
-          return result === target ? receiver : result;
-        };
+          const result = original.apply(target, translatedArgs)
+          return result === target ? receiver : result
+        }
       },
-    };
+    }
 
-    return new Proxy(joinClause, handler);
+    return new Proxy(joinClause, handler)
   }
 
-  #handleJoin(method, args) {
-    if (args.length === 0) return args;
-    const [tableExpression, ...rest] = args;
-    const parsed = parseTableExpression(tableExpression);
+  #handleJoin (method, args) {
+    if (args.length === 0) return args
+    const [tableExpression, ...rest] = args
+    const parsed = parseTableExpression(tableExpression)
 
     if (!parsed.tableName || !parsed.alias) {
-      return args;
+      return args
     }
 
-    const resource = this.tableNameToResource.get(parsed.tableName) || parsed.tableName;
-    const descriptor = this.descriptorsMap.get(resource);
+    const resource = this.tableNameToResource.get(parsed.tableName) || parsed.tableName
+    const descriptor = this.descriptorsMap.get(resource)
 
     if (!descriptor) {
-      return args;
+      return args
     }
 
-    this.registerAlias(parsed.alias, descriptor);
+    this.registerAlias(parsed.alias, descriptor)
 
-    const joinTarget = { [parsed.alias]: descriptor.canonical.tableName };
+    const joinTarget = { [parsed.alias]: descriptor.canonical.tableName }
 
     if (rest.length === 0) {
-      return [joinTarget];
+      return [joinTarget]
     }
 
-    const [first, ...remaining] = rest;
+    const [first, ...remaining] = rest
 
     if (isFunction(first)) {
-      const joinCallback = first;
+      const joinCallback = first
       const wrappedCallback = (joinClause) => {
-        this.#addResourceConstraints(joinClause, parsed.alias, descriptor);
-        const proxyClause = this.#createJoinProxy(joinClause);
-        return joinCallback.call(proxyClause, proxyClause);
-      };
-      return [joinTarget, wrappedCallback, ...remaining];
+        this.#addResourceConstraints(joinClause, parsed.alias, descriptor)
+        const proxyClause = this.#createJoinProxy(joinClause)
+        return joinCallback.call(proxyClause, proxyClause)
+      }
+      return [joinTarget, wrappedCallback, ...remaining]
     }
 
     const translatedArgs = rest.map((value, index) => {
       if (index === 0 || index === 1) {
-        return this.translateColumn(value);
+        return this.translateColumn(value)
       }
-      return value;
-    });
+      return value
+    })
 
-    return [joinTarget, ...translatedArgs];
+    return [joinTarget, ...translatedArgs]
   }
 
-  #createProxy(builder) {
-    const adapter = this;
+  #createProxy (builder) {
+    const adapter = this
     const handler = {
-      get(target, prop, receiver) {
+      get (target, prop, receiver) {
         if (prop === '__adapter__') {
-          return adapter;
+          return adapter
         }
 
-        const value = target[prop];
+        const value = target[prop]
         if (typeof value !== 'function') {
-          return Reflect.get(target, prop, receiver);
+          return Reflect.get(target, prop, receiver)
         }
 
         if (JOIN_METHODS.has(prop)) {
           return (...args) => {
-            const translatedArgs = adapter.#handleJoin(prop, args);
-            const result = value.apply(target, translatedArgs);
-            return result === target ? receiver : result;
-          };
+            const translatedArgs = adapter.#handleJoin(prop, args)
+            const result = value.apply(target, translatedArgs)
+            return result === target ? receiver : result
+          }
         }
 
         return (...args) => {
-          let translatedArgs = args;
+          let translatedArgs = args
 
           if (WHERE_METHODS.has(prop)) {
-            translatedArgs = adapter.#translateWhereArgs(prop, args);
+            translatedArgs = adapter.#translateWhereArgs(prop, args)
           } else if (WHERE_IN_METHODS.has(prop)) {
-            translatedArgs = adapter.#translateWhereInArgs(args);
+            translatedArgs = adapter.#translateWhereInArgs(args)
           } else if (BETWEEN_METHODS.has(prop)) {
-            translatedArgs = adapter.#translateBetweenArgs(args);
+            translatedArgs = adapter.#translateBetweenArgs(args)
           } else if (NULL_METHODS.has(prop)) {
-            translatedArgs = adapter.#translateNullArgs(args);
+            translatedArgs = adapter.#translateNullArgs(args)
           } else if (JOIN_ON_METHODS.has(prop)) {
-            translatedArgs = adapter.#translateOnArgs(args);
+            translatedArgs = adapter.#translateOnArgs(args)
           } else if (JOIN_ON_IN_METHODS.has(prop)) {
-            translatedArgs = adapter.#translateOnInArgs(args);
+            translatedArgs = adapter.#translateOnInArgs(args)
           } else if (JOIN_ON_BETWEEN_METHODS.has(prop)) {
-            translatedArgs = adapter.#translateOnBetweenArgs(args);
+            translatedArgs = adapter.#translateOnBetweenArgs(args)
           } else if (JOIN_ON_NULL_METHODS.has(prop)) {
-            translatedArgs = adapter.#translateOnNullArgs(args);
+            translatedArgs = adapter.#translateOnNullArgs(args)
           } else if (ORDER_METHODS.has(prop)) {
-            translatedArgs = adapter.#translateOrderArgs(prop, args);
+            translatedArgs = adapter.#translateOrderArgs(prop, args)
           } else if (GROUP_METHODS.has(prop)) {
-            translatedArgs = adapter.#translateGroupArgs(args);
+            translatedArgs = adapter.#translateGroupArgs(args)
           } else if (SELECT_METHODS.has(prop)) {
-            translatedArgs = adapter.#translateSelectArgs(args);
+            translatedArgs = adapter.#translateSelectArgs(args)
           } else if (AGGREGATE_METHODS.has(prop)) {
-            translatedArgs = adapter.#translateAggregateArgs(args);
+            translatedArgs = adapter.#translateAggregateArgs(args)
           } else if (CALLBACK_FIRST_METHODS.has(prop) && args.length && isFunction(args[0])) {
-            translatedArgs = [maybeWrapCallback(adapter, args[0]), ...args.slice(1)];
+            translatedArgs = [maybeWrapCallback(adapter, args[0]), ...args.slice(1)]
           }
 
-          const result = value.apply(target, translatedArgs);
-          return result === target ? receiver : result;
-        };
+          const result = value.apply(target, translatedArgs)
+          return result === target ? receiver : result
+        }
       },
-    };
+    }
 
-    const proxy = new Proxy(builder, handler);
-    this.builders.set(proxy, builder);
-    return proxy;
+    const proxy = new Proxy(builder, handler)
+    this.builders.set(proxy, builder)
+    return proxy
   }
 }