metal-orm 1.0.43 → 1.0.45

package/src/query-builder/relation-conditions.ts

@@ -21,26 +21,26 @@ const assertNever = (value: never): never => {
  * @param relation - Relation definition
  * @returns Expression node representing the join condition
  */
-const baseRelationCondition = (root: TableDef, relation: RelationDef, rootAlias?: string): ExpressionNode => {
-  const rootTable = rootAlias || root.name;
-  const defaultLocalKey =
-  relation.type === RelationKinds.HasMany || relation.type === RelationKinds.HasOne
-    ? findPrimaryKey(root)
-    : findPrimaryKey(relation.target);
-  const localKey = relation.localKey || defaultLocalKey;
+const baseRelationCondition = (root: TableDef, relation: RelationDef, rootAlias?: string): ExpressionNode => {
+  const rootTable = rootAlias || root.name;
+  const defaultLocalKey =
+    relation.type === RelationKinds.HasMany || relation.type === RelationKinds.HasOne
+      ? findPrimaryKey(root)
+      : findPrimaryKey(relation.target);
+  const localKey = relation.localKey || defaultLocalKey;
 
   switch (relation.type) {
-    case RelationKinds.HasMany:
-    case RelationKinds.HasOne:
-      return eq(
-        { type: 'Column', table: relation.target.name, name: relation.foreignKey },
-        { type: 'Column', table: rootTable, name: localKey }
-      );
-    case RelationKinds.BelongsTo:
-      return eq(
-        { type: 'Column', table: relation.target.name, name: localKey },
-        { type: 'Column', table: rootTable, name: relation.foreignKey }
-      );
+    case RelationKinds.HasMany:
+    case RelationKinds.HasOne:
+      return eq(
+        { type: 'Column', table: relation.target.name, name: relation.foreignKey },
+        { type: 'Column', table: rootTable, name: localKey }
+      );
+    case RelationKinds.BelongsTo:
+      return eq(
+        { type: 'Column', table: relation.target.name, name: localKey },
+        { type: 'Column', table: rootTable, name: relation.foreignKey }
+      );
     case RelationKinds.BelongsToMany:
       throw new Error('BelongsToMany relations do not support the standard join condition builder');
     default:
@@ -50,25 +50,36 @@ const baseRelationCondition = (root: TableDef, relation: RelationDef, rootAlias?
 
 /**
  * Builds the join nodes required to include a BelongsToMany relation.
+ * @param root - The root table definition
+ * @param relationName - Name of the relation being joined
+ * @param relation - The BelongsToMany relation definition
+ * @param joinKind - The type of join to perform
+ * @param extra - Optional additional conditions for the target join
+ * @param rootAlias - Optional alias for the root table
+ * @returns Array of join nodes for the pivot and target tables
  */
-export const buildBelongsToManyJoins = (
-  root: TableDef,
-  relationName: string,
-  relation: BelongsToManyRelation,
-  joinKind: JoinKind,
-  extra?: ExpressionNode,
-  rootAlias?: string
-): JoinNode[] => {
-  const rootKey = relation.localKey || findPrimaryKey(root);
-  const targetKey = relation.targetKey || findPrimaryKey(relation.target);
-  const rootTable = rootAlias || root.name;
-
-  const pivotCondition = eq(
-    { type: 'Column', table: relation.pivotTable.name, name: relation.pivotForeignKeyToRoot },
-    { type: 'Column', table: rootTable, name: rootKey }
-  );
+export const buildBelongsToManyJoins = (
+  root: TableDef,
+  relationName: string,
+  relation: BelongsToManyRelation,
+  joinKind: JoinKind,
+  extra?: ExpressionNode,
+  rootAlias?: string
+): JoinNode[] => {
+  const rootKey = relation.localKey || findPrimaryKey(root);
+  const targetKey = relation.targetKey || findPrimaryKey(relation.target);
+  const rootTable = rootAlias || root.name;
 
-  const pivotJoin = createJoinNode(joinKind, relation.pivotTable.name, pivotCondition);
+  const pivotCondition = eq(
+    { type: 'Column', table: relation.pivotTable.name, name: relation.pivotForeignKeyToRoot },
+    { type: 'Column', table: rootTable, name: rootKey }
+  );
+
+  const pivotJoin = createJoinNode(
+    joinKind,
+    { type: 'Table', name: relation.pivotTable.name, schema: relation.pivotTable.schema },
+    pivotCondition
+  );
 
   let targetCondition: ExpressionNode = eq(
     { type: 'Column', table: relation.target.name, name: targetKey },
@@ -81,7 +92,7 @@ export const buildBelongsToManyJoins = (
 
   const targetJoin = createJoinNode(
     joinKind,
-    relation.target.name,
+    { type: 'Table', name: relation.target.name, schema: relation.target.schema },
     targetCondition,
     relationName
   );
@@ -94,24 +105,26 @@ export const buildBelongsToManyJoins = (
  * @param root - Root table definition
  * @param relation - Relation definition
  * @param extra - Optional additional expression to combine with AND
+ * @param rootAlias - Optional alias for the root table
  * @returns Expression node representing the complete join condition
  */
-export const buildRelationJoinCondition = (
-  root: TableDef,
-  relation: RelationDef,
-  extra?: ExpressionNode,
-  rootAlias?: string
-): ExpressionNode => {
-  const base = baseRelationCondition(root, relation, rootAlias);
-  return extra ? and(base, extra) : base;
-};
+export const buildRelationJoinCondition = (
+  root: TableDef,
+  relation: RelationDef,
+  extra?: ExpressionNode,
+  rootAlias?: string
+): ExpressionNode => {
+  const base = baseRelationCondition(root, relation, rootAlias);
+  return extra ? and(base, extra) : base;
+};
 
 /**
  * Builds a relation correlation condition for subqueries
  * @param root - Root table definition
  * @param relation - Relation definition
+ * @param rootAlias - Optional alias for the root table
  * @returns Expression node representing the correlation condition
  */
-export const buildRelationCorrelation = (root: TableDef, relation: RelationDef, rootAlias?: string): ExpressionNode => {
-  return baseRelationCondition(root, relation, rootAlias);
-};
+export const buildRelationCorrelation = (root: TableDef, relation: RelationDef, rootAlias?: string): ExpressionNode => {
+  return baseRelationCondition(root, relation, rootAlias);
+};

package/src/query-builder/relation-service.ts

@@ -20,8 +20,8 @@ import {
 } from './relation-conditions.js';
 import { JoinKind, JOIN_KINDS } from '../core/sql/sql.js';
 import { RelationIncludeOptions } from './relation-types.js';
-import { createJoinNode } from '../core/ast/join-node.js';
-import { getJoinRelationName } from '../core/ast/join-metadata.js';
+import { createJoinNode } from '../core/ast/join-node.js';
+import { getJoinRelationName } from '../core/ast/join-metadata.js';
 import { makeRelationAlias } from './relation-alias.js';
 import { buildDefaultPivotColumns } from './relation-utils.js';
 
@@ -70,17 +70,17 @@ export class RelationService {
    * @param predicate - Optional predicate expression
    * @returns Relation result with updated state and hydration
    */
-  match(
-    relationName: string,
-    predicate?: ExpressionNode
-  ): RelationResult {
-    const joined = this.joinRelation(relationName, JOIN_KINDS.INNER, predicate);
-    const pk = findPrimaryKey(this.table);
-    const distinctCols: ColumnNode[] = [{ type: 'Column', table: this.rootTableName(), name: pk }];
-    const existingDistinct = joined.state.ast.distinct ? joined.state.ast.distinct : [];
-    const nextState = this.astService(joined.state).withDistinct([...existingDistinct, ...distinctCols]);
-    return { state: nextState, hydration: joined.hydration };
-  }
+  match(
+    relationName: string,
+    predicate?: ExpressionNode
+  ): RelationResult {
+    const joined = this.joinRelation(relationName, JOIN_KINDS.INNER, predicate);
+    const pk = findPrimaryKey(this.table);
+    const distinctCols: ColumnNode[] = [{ type: 'Column', table: this.rootTableName(), name: pk }];
+    const existingDistinct = joined.state.ast.distinct ? joined.state.ast.distinct : [];
+    const nextState = this.astService(joined.state).withDistinct([...existingDistinct, ...distinctCols]);
+    return { state: nextState, hydration: joined.hydration };
+  }
 
   /**
    * Includes a relation in the query result
@@ -94,7 +94,7 @@ export class RelationService {
 
     const relation = this.getRelation(relationName);
     const aliasPrefix = options?.aliasPrefix ?? relationName;
-    const alreadyJoined = state.ast.joins.some(j => getJoinRelationName(j) === relationName);
+    const alreadyJoined = state.ast.joins.some(j => getJoinRelationName(j) === relationName);
 
     if (!alreadyJoined) {
       const joined = this.joinRelation(relationName, options?.joinKind ?? JOIN_KINDS.LEFT, options?.filter);
@@ -114,7 +114,7 @@ export class RelationService {
       prefix: string,
       keys: string[],
       missingMsg: (col: string) => string
-    ) : Record<string, ColumnDef> => {
+    ): Record<string, ColumnDef> => {
       return keys.reduce((acc, key) => {
         const def = columns[key];
         if (!def) {
@@ -190,22 +190,22 @@ export class RelationService {
    * @param ast - Query AST to modify
    * @returns Modified query AST with relation correlation
    */
-  applyRelationCorrelation(
-    relationName: string,
-    ast: SelectQueryNode,
-    additionalCorrelation?: ExpressionNode
-  ): SelectQueryNode {
-    const relation = this.getRelation(relationName);
-    const rootAlias = this.state.ast.from.type === 'Table' ? this.state.ast.from.alias : undefined;
-    let correlation = buildRelationCorrelation(this.table, relation, rootAlias);
-    if (additionalCorrelation) {
-      correlation = and(correlation, additionalCorrelation);
-    }
-    const whereInSubquery = ast.where
-      ? and(correlation, ast.where)
-      : correlation;
-
-    return {
+  applyRelationCorrelation(
+    relationName: string,
+    ast: SelectQueryNode,
+    additionalCorrelation?: ExpressionNode
+  ): SelectQueryNode {
+    const relation = this.getRelation(relationName);
+    const rootAlias = this.state.ast.from.type === 'Table' ? this.state.ast.from.alias : undefined;
+    let correlation = buildRelationCorrelation(this.table, relation, rootAlias);
+    if (additionalCorrelation) {
+      correlation = and(correlation, additionalCorrelation);
+    }
+    const whereInSubquery = ast.where
+      ? and(correlation, ast.where)
+      : correlation;
+
+    return {
       ...ast,
       where: whereInSubquery
     };
@@ -219,28 +219,33 @@ export class RelationService {
    * @param extraCondition - Additional join condition
    * @returns Updated query state with join
    */
-  private withJoin(
-    state: SelectQueryState,
-    relationName: string,
-    joinKind: JoinKind,
-    extraCondition?: ExpressionNode
-  ): SelectQueryState {
-    const relation = this.getRelation(relationName);
-    const rootAlias = state.ast.from.type === 'Table' ? state.ast.from.alias : undefined;
-    if (relation.type === RelationKinds.BelongsToMany) {
-      const joins = buildBelongsToManyJoins(
-        this.table,
-        relationName,
-        relation as BelongsToManyRelation,
-        joinKind,
-        extraCondition,
-        rootAlias
-      );
-      return joins.reduce((current, join) => this.astService(current).withJoin(join), state);
-    }
-
-    const condition = buildRelationJoinCondition(this.table, relation, extraCondition, rootAlias);
-    const joinNode = createJoinNode(joinKind, relation.target.name, condition, relationName);
+  private withJoin(
+    state: SelectQueryState,
+    relationName: string,
+    joinKind: JoinKind,
+    extraCondition?: ExpressionNode
+  ): SelectQueryState {
+    const relation = this.getRelation(relationName);
+    const rootAlias = state.ast.from.type === 'Table' ? state.ast.from.alias : undefined;
+    if (relation.type === RelationKinds.BelongsToMany) {
+      const joins = buildBelongsToManyJoins(
+        this.table,
+        relationName,
+        relation as BelongsToManyRelation,
+        joinKind,
+        extraCondition,
+        rootAlias
+      );
+      return joins.reduce((current, join) => this.astService(current).withJoin(join), state);
+    }
+
+    const condition = buildRelationJoinCondition(this.table, relation, extraCondition, rootAlias);
+    const joinNode = createJoinNode(
+      joinKind,
+      { type: 'Table', name: relation.target.name, schema: relation.target.schema },
+      condition,
+      relationName
+    );
 
     return this.astService(state).withJoin(joinNode);
   }
@@ -284,15 +289,15 @@ export class RelationService {
    * @param state - Current query state
    * @returns QueryAstService instance
    */
-  private astService(state: SelectQueryState = this.state): QueryAstService {
-    return this.createQueryAstService(this.table, state);
-  }
-
-  private rootTableName(): string {
-    const from = this.state.ast.from;
-    if (from.type === 'Table' && from.alias) return from.alias;
-    return this.table.name;
-  }
-}
+  private astService(state: SelectQueryState = this.state): QueryAstService {
+    return this.createQueryAstService(this.table, state);
+  }
+
+  private rootTableName(): string {
+    const from = this.state.ast.from;
+    if (from.type === 'Table' && from.alias) return from.alias;
+    return this.table.name;
+  }
+}
 
 export type { RelationResult } from './relation-projection-helper.js';

package/src/query-builder/relation-utils.ts

@@ -2,6 +2,9 @@ import { BelongsToManyRelation } from '../schema/relation.js';
 
 /**
  * Builds a default set of pivot columns, excluding keys used for joins.
+ * @param rel - The BelongsToMany relation definition
+ * @param pivotPk - The primary key column name of the pivot table
+ * @returns Array of column names that can be included in pivot table selections
  */
 export const buildDefaultPivotColumns = (
   rel: BelongsToManyRelation,

package/src/query-builder/select/cte-facet.ts

@@ -0,0 +1,40 @@
+import { SelectQueryNode } from '../../core/ast/query.js';
+import { SelectQueryBuilderContext, SelectQueryBuilderEnvironment } from '../select-query-builder-deps.js';
+import { QueryAstService } from '../query-ast-service.js';
+import { SelectQueryState } from '../select-query-state.js';
+
+/**
+ * Facet responsible for Common Table Expressions (WITH clauses)
+ */
+export class SelectCTEFacet {
+    /**
+     * Creates a new SelectCTEFacet instance
+     * @param env - Query builder environment
+     * @param createAstService - Function to create AST service
+     */
+    constructor(
+        private readonly env: SelectQueryBuilderEnvironment,
+        private readonly createAstService: (state: SelectQueryState) => QueryAstService
+    ) { }
+
+    /**
+     * Adds a Common Table Expression to the query
+     * @param context - Current query context
+     * @param name - CTE name
+     * @param subAst - CTE query AST
+     * @param columns - Optional column names
+     * @param recursive - Whether the CTE is recursive
+     * @returns Updated query context with CTE
+     */
+    withCTE(
+        context: SelectQueryBuilderContext,
+        name: string,
+        subAst: SelectQueryNode,
+        columns: string[] | undefined,
+        recursive: boolean
+    ): SelectQueryBuilderContext {
+        const astService = this.createAstService(context.state);
+        const nextState = astService.withCte(name, subAst, columns, recursive);
+        return { state: nextState, hydration: context.hydration };
+    }
+}

package/src/query-builder/select/from-facet.ts

@@ -0,0 +1,80 @@
+import { SelectQueryNode } from '../../core/ast/query.js';
+import { OperandNode } from '../../core/ast/expression.js';
+import { derivedTable, fnTable } from '../../core/ast/builders.js';
+import { SelectQueryBuilderContext, SelectQueryBuilderEnvironment } from '../select-query-builder-deps.js';
+import { QueryAstService } from '../query-ast-service.js';
+import { SelectQueryState } from '../select-query-state.js';
+
+/**
+ * Facet responsible for FROM clause operations
+ */
+export class SelectFromFacet {
+    /**
+     * Creates a new SelectFromFacet instance
+     * @param env - Query builder environment
+     * @param createAstService - Function to create AST service
+     */
+    constructor(
+        private readonly env: SelectQueryBuilderEnvironment,
+        private readonly createAstService: (state: SelectQueryState) => QueryAstService
+    ) { }
+
+    /**
+     * Applies an alias to the FROM table
+     * @param context - Current query context
+     * @param alias - Alias to apply
+     * @returns Updated query context with aliased FROM
+     */
+    as(context: SelectQueryBuilderContext, alias: string): SelectQueryBuilderContext {
+        const from = context.state.ast.from;
+        if (from.type !== 'Table') {
+            throw new Error('Cannot alias non-table FROM sources');
+        }
+        const nextFrom = { ...from, alias };
+        const astService = this.createAstService(context.state);
+        const nextState = astService.withFrom(nextFrom);
+        return { state: nextState, hydration: context.hydration };
+    }
+
+    /**
+     * Sets the FROM clause to a subquery
+     * @param context - Current query context
+     * @param subAst - Subquery AST
+     * @param alias - Alias for the subquery
+     * @param columnAliases - Optional column aliases
+     * @returns Updated query context with subquery FROM
+     */
+    fromSubquery(
+        context: SelectQueryBuilderContext,
+        subAst: SelectQueryNode,
+        alias: string,
+        columnAliases?: string[]
+    ): SelectQueryBuilderContext {
+        const fromNode = derivedTable(subAst, alias, columnAliases);
+        const astService = this.createAstService(context.state);
+        const nextState = astService.withFrom(fromNode);
+        return { state: nextState, hydration: context.hydration };
+    }
+
+    /**
+     * Sets the FROM clause to a function table
+     * @param context - Current query context
+     * @param name - Function name
+     * @param args - Function arguments
+     * @param alias - Optional alias for the function table
+     * @param options - Optional function table options
+     * @returns Updated query context with function table FROM
+     */
+    fromFunctionTable(
+        context: SelectQueryBuilderContext,
+        name: string,
+        args: OperandNode[],
+        alias?: string,
+        options?: { lateral?: boolean; withOrdinality?: boolean; columnAliases?: string[]; schema?: string }
+    ): SelectQueryBuilderContext {
+        const functionTable = fnTable(name, args, alias, options);
+        const astService = this.createAstService(context.state);
+        const nextState = astService.withFrom(functionTable);
+        return { state: nextState, hydration: context.hydration };
+    }
+}

package/src/query-builder/select/join-facet.ts

@@ -0,0 +1,62 @@
+import { TableDef } from '../../schema/table.js';
+import { BinaryExpressionNode } from '../../core/ast/expression.js';
+import { SelectQueryNode } from '../../core/ast/query.js';
+import { JoinKind } from '../../core/sql/sql.js';
+import { derivedTable, fnTable } from '../../core/ast/builders.js';
+import { createJoinNode } from '../../core/ast/join-node.js';
+import { SelectQueryBuilderContext, SelectQueryBuilderEnvironment } from '../select-query-builder-deps.js';
+import { QueryAstService } from '../query-ast-service.js';
+import { OperandNode } from '../../core/ast/expression.js';
+import { SelectQueryState } from '../select-query-state.js';
+
+/**
+ * Facet responsible for JOIN operations
+ */
+export class SelectJoinFacet {
+    constructor(
+        private readonly env: SelectQueryBuilderEnvironment,
+        private readonly createAstService: (state: SelectQueryState) => QueryAstService
+    ) { }
+
+    applyJoin(
+        context: SelectQueryBuilderContext,
+        table: TableDef,
+        condition: BinaryExpressionNode,
+        kind: JoinKind
+    ): SelectQueryBuilderContext {
+        const joinNode = createJoinNode(kind, { type: 'Table', name: table.name, schema: table.schema }, condition);
+        const astService = this.createAstService(context.state);
+        const nextState = astService.withJoin(joinNode);
+        return { state: nextState, hydration: context.hydration };
+    }
+
+    joinSubquery(
+        context: SelectQueryBuilderContext,
+        subAst: SelectQueryNode,
+        alias: string,
+        condition: BinaryExpressionNode,
+        joinKind: JoinKind,
+        columnAliases?: string[]
+    ): SelectQueryBuilderContext {
+        const joinNode = createJoinNode(joinKind, derivedTable(subAst, alias, columnAliases), condition);
+        const astService = this.createAstService(context.state);
+        const nextState = astService.withJoin(joinNode);
+        return { state: nextState, hydration: context.hydration };
+    }
+
+    joinFunctionTable(
+        context: SelectQueryBuilderContext,
+        name: string,
+        args: OperandNode[],
+        alias: string,
+        condition: BinaryExpressionNode,
+        joinKind: JoinKind,
+        options?: { lateral?: boolean; withOrdinality?: boolean; columnAliases?: string[]; schema?: string }
+    ): SelectQueryBuilderContext {
+        const functionTable = fnTable(name, args, alias, options);
+        const joinNode = createJoinNode(joinKind, functionTable, condition);
+        const astService = this.createAstService(context.state);
+        const nextState = astService.withJoin(joinNode);
+        return { state: nextState, hydration: context.hydration };
+    }
+}

package/src/query-builder/select/predicate-facet.ts

@@ -0,0 +1,103 @@
+import { ColumnDef } from '../../schema/column.js';
+import { ExpressionNode } from '../../core/ast/expression.js';
+import { OrderingTerm } from '../../core/ast/query.js';
+import { OrderDirection } from '../../core/sql/sql.js';
+import { SelectQueryBuilderContext, SelectQueryBuilderEnvironment } from '../select-query-builder-deps.js';
+import { QueryAstService } from '../query-ast-service.js';
+import { SelectQueryState } from '../select-query-state.js';
+
+/**
+ * Facet responsible for filtering and ordering operations
+ */
+export class SelectPredicateFacet {
+    /**
+     * Creates a new SelectPredicateFacet instance
+     * @param env - Query builder environment
+     * @param createAstService - Function to create AST service
+     */
+    constructor(
+        private readonly env: SelectQueryBuilderEnvironment,
+        private readonly createAstService: (state: SelectQueryState) => QueryAstService
+    ) { }
+
+    /**
+     * Adds a WHERE condition to the query
+     * @param context - Current query context
+     * @param expr - WHERE expression
+     * @returns Updated query context with WHERE condition
+     */
+    where(context: SelectQueryBuilderContext, expr: ExpressionNode): SelectQueryBuilderContext {
+        const astService = this.createAstService(context.state);
+        const nextState = astService.withWhere(expr);
+        return { state: nextState, hydration: context.hydration };
+    }
+
+    /**
+     * Adds a GROUP BY clause to the query
+     * @param context - Current query context
+     * @param term - Column or ordering term to group by
+     * @returns Updated query context with GROUP BY clause
+     */
+    groupBy(context: SelectQueryBuilderContext, term: ColumnDef | OrderingTerm): SelectQueryBuilderContext {
+        const astService = this.createAstService(context.state);
+        const nextState = astService.withGroupBy(term);
+        return { state: nextState, hydration: context.hydration };
+    }
+
+    /**
+     * Adds a HAVING condition to the query
+     * @param context - Current query context
+     * @param expr - HAVING expression
+     * @returns Updated query context with HAVING condition
+     */
+    having(context: SelectQueryBuilderContext, expr: ExpressionNode): SelectQueryBuilderContext {
+        const astService = this.createAstService(context.state);
+        const nextState = astService.withHaving(expr);
+        return { state: nextState, hydration: context.hydration };
+    }
+
+    /**
+     * Adds an ORDER BY clause to the query
+     * @param context - Current query context
+     * @param term - Column or ordering term to order by
+     * @param direction - Order direction
+     * @param nulls - Nulls ordering
+     * @param collation - Collation
+     * @returns Updated query context with ORDER BY clause
+     */
+    orderBy(
+        context: SelectQueryBuilderContext,
+        term: ColumnDef | OrderingTerm,
+        direction: OrderDirection,
+        nulls?: 'FIRST' | 'LAST',
+        collation?: string
+    ): SelectQueryBuilderContext {
+        const astService = this.createAstService(context.state);
+        const nextState = astService.withOrderBy(term, direction, nulls, collation);
+        return { state: nextState, hydration: context.hydration };
+    }
+
+    /**
+     * Adds a LIMIT clause to the query
+     * @param context - Current query context
+     * @param n - Maximum number of rows
+     * @returns Updated query context with LIMIT clause
+     */
+    limit(context: SelectQueryBuilderContext, n: number): SelectQueryBuilderContext {
+        const astService = this.createAstService(context.state);
+        const nextState = astService.withLimit(n);
+        return { state: nextState, hydration: context.hydration };
+    }
+
+    /**
+     * Adds an OFFSET clause to the query
+     * @param context - Current query context
+     * @param n - Number of rows to skip
+     * @returns Updated query context with OFFSET clause
+     */
+    offset(context: SelectQueryBuilderContext, n: number): SelectQueryBuilderContext {
+        const astService = this.createAstService(context.state);
+        const nextState = astService.withOffset(n);
+        return { state: nextState, hydration: context.hydration };
+    }
+}