@decaf-ts/core
Version:
Core persistence module for the decaf framework
333 lines • 41.8 kB
JavaScript
"use strict";
var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
return c > 3 && r && Object.defineProperty(target, key, r), r;
};
var __metadata = (this && this.__metadata) || function (k, v) {
if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.Condition = void 0;
const decorator_validation_1 = require("@decaf-ts/decorator-validation");
const constants_1 = require("./constants.cjs");
const errors_1 = require("./errors.cjs");
/**
* @description Represents a logical condition for database queries
* @summary A class that encapsulates query conditions with support for complex logical operations.
* This class allows for building and combining query conditions using logical operators (AND, OR, NOT)
* and comparison operators (equals, not equals, greater than, etc.).
* @template M - The model type this condition operates on
* @param {string | Condition<M>} attr1 - The attribute name or a nested condition
* @param {Operator | GroupOperator} operator - The operator to use for the condition
* @param {any} comparison - The value to compare against or another condition
* @class Condition
* @example
* // Create a simple condition
* const nameCondition = Condition.attribute("name").eq("John");
*
* // Create a complex condition
* const complexCondition = Condition.attribute("age").gt(18)
* .and(Condition.attribute("status").eq("active"));
*
* // Use the builder pattern
* const userQuery = Condition.builder()
* .attribute("email").regexp(".*@example.com")
* .and(Condition.attribute("lastLogin").gt(new Date("2023-01-01")));
*/
class Condition extends decorator_validation_1.Model {
constructor(attr1, operator, comparison) {
super();
this.attr1 = undefined;
this.operator = undefined;
this.comparison = undefined;
this.attr1 = attr1;
this.operator = operator;
this.comparison = comparison;
}
/**
* @description Combines this condition with another using logical AND
* @summary Joins two conditions with an AND operator, requiring both to be true
* @param {Condition<M>} condition - The condition to combine with this one
* @return {Condition<M>} A new condition representing the AND operation
*/
and(condition) {
return Condition.and(this, condition);
}
/**
* @description Combines this condition with another using logical OR
* @summary Joins two conditions with an OR operator, requiring at least one to be true
* @param {Condition<M>} condition - The condition to combine with this one
* @return {Condition<M>} A new condition representing the OR operation
*/
or(condition) {
return Condition.or(this, condition);
}
/**
* @description Creates a negation condition
* @summary Excludes a value from the result by applying a NOT operator
* @param {any} val - The value to negate
* @return {Condition<M>} A new condition representing the NOT operation
*/
not(val) {
return new Condition(this, constants_1.Operator.NOT, val);
}
/**
* @description Validates the condition and checks for errors
* @summary Extends the base validation to ensure the condition is properly formed
* @param {...string[]} exceptions - Fields to exclude from validation
* @return {ModelErrorDefinition | undefined} Error definition if validation fails, undefined otherwise
*/
hasErrors(...exceptions) {
const conditionCheck = () => {
const invalidOpMessage = `Invalid operator ${this.operator}}`;
if (typeof this.attr1 === "string") {
if (this.comparison instanceof Condition)
return {
comparison: {
condition: "Both sides of the comparison must be of the same type",
},
};
if (Object.values(constants_1.Operator).indexOf(this.operator) === -1)
return {
operator: {
condition: invalidOpMessage,
},
};
}
if (this.attr1 instanceof Condition) {
if (!(this.comparison instanceof Condition) &&
this.operator !== constants_1.Operator.NOT)
return {
comparison: {
condition: invalidOpMessage,
},
};
if (Object.values(constants_1.GroupOperator).indexOf(this.operator) === -1 &&
this.operator !== constants_1.Operator.NOT)
return {
operator: {
condition: invalidOpMessage,
},
};
}
};
const errors = super.hasErrors(...exceptions);
if (!this.isAsync())
return (errors ??
conditionCheck());
return (async () => {
const resolved = await Promise.resolve(errors);
return resolved ?? conditionCheck();
})();
}
/**
* @description Creates a new condition that combines two conditions with logical AND
* @summary Static method that joins two conditions with an AND operator, requiring both to be true
* @template M - The model type this condition operates on
* @param {Condition<M>} condition1 - The first condition
* @param {Condition<M>} condition2 - The second condition
* @return {Condition<M>} A new condition representing the AND operation
*/
static and(condition1, condition2) {
return Condition.group(condition1, constants_1.GroupOperator.AND, condition2);
}
/**
* @description Creates a new condition that combines two conditions with logical OR
* @summary Static method that joins two conditions with an OR operator, requiring at least one to be true
* @template M - The model type this condition operates on
* @param {Condition<M>} condition1 - The first condition
* @param {Condition<M>} condition2 - The second condition
* @return {Condition<M>} A new condition representing the OR operation
*/
static or(condition1, condition2) {
return Condition.group(condition1, constants_1.GroupOperator.OR, condition2);
}
/**
* @description Creates a new condition that groups two conditions with a specified operator
* @summary Private static method that combines two conditions using the specified group operator
* @template M - The model type this condition operates on
* @param {Condition<M>} condition1 - The first condition
* @param {GroupOperator} operator - The group operator to use (AND, OR)
* @param {Condition<M>} condition2 - The second condition
* @return {Condition<M>} A new condition representing the grouped operation
*/
static group(condition1, operator, condition2) {
return new Condition(condition1, operator, condition2);
}
/**
* @description Creates a condition builder for a specific model attribute
* @summary Static method that initializes a condition builder with the specified attribute
* @template M - The model type this condition operates on
* @param attr - The model attribute to build a condition for
* @return {AttributeOption<M>} A condition builder initialized with the attribute
*/
static attribute(attr) {
return new Condition.Builder().attribute(attr);
}
/**
* @description Alias for the attribute method
* @summary Shorthand method that initializes a condition builder with the specified attribute
* @template M - The model type this condition operates on
* @param attr - The model attribute to build a condition for
* @return {AttributeOption<M>} A condition builder initialized with the attribute
*/
static attr(attr) {
return this.attribute(attr);
}
/**
* @description Provides a fluent API to build query conditions
* @summary A builder class that simplifies the creation of database query conditions
* with a chainable interface for setting attributes and operators
* @template M - The model type this condition builder operates on
* @class ConditionBuilder
*/
static { this.Builder = class ConditionBuilder {
constructor() {
this.attr1 = undefined;
this.operator = undefined;
this.comparison = undefined;
}
/**
* @description Sets the attribute for the condition
* @summary Specifies which model attribute the condition will operate on
* @param attr - The model attribute to use in the condition
* @return {AttributeOption<M>} This builder instance for method chaining
*/
attribute(attr) {
this.attr1 = attr;
return this;
}
/**
* @description Alias for the attribute method
* @summary Shorthand method to specify which model attribute the condition will operate on
* @param attr - The model attribute to use in the condition
* @return {AttributeOption<M>} This builder instance for method chaining
*/
attr(attr) {
return this.attribute(attr);
}
/**
* @description Creates an equality condition
* @summary Builds a condition that checks if the attribute equals the specified value
* @param {any} val - The value to compare the attribute against
* @return {Condition<M>} A new condition representing the equality comparison
*/
eq(val) {
return this.setOp(constants_1.Operator.EQUAL, val);
}
/**
* @description Creates an inequality condition
* @summary Builds a condition that checks if the attribute is different from the specified value
* @param {any} val - The value to compare the attribute against
* @return {Condition<M>} A new condition representing the inequality comparison
*/
dif(val) {
return this.setOp(constants_1.Operator.DIFFERENT, val);
}
/**
* @description Creates a greater than condition
* @summary Builds a condition that checks if the attribute is greater than the specified value
* @param {any} val - The value to compare the attribute against
* @return {Condition<M>} A new condition representing the greater than comparison
*/
gt(val) {
return this.setOp(constants_1.Operator.BIGGER, val);
}
/**
* @description Creates a less than condition
* @summary Builds a condition that checks if the attribute is less than the specified value
* @param {any} val - The value to compare the attribute against
* @return {Condition<M>} A new condition representing the less than comparison
*/
lt(val) {
return this.setOp(constants_1.Operator.SMALLER, val);
}
/**
* @description Creates a greater than or equal to condition
* @summary Builds a condition that checks if the attribute is greater than or equal to the specified value
* @param {any} val - The value to compare the attribute against
* @return {Condition<M>} A new condition representing the greater than or equal comparison
*/
gte(val) {
return this.setOp(constants_1.Operator.BIGGER_EQ, val);
}
/**
* @description Creates a less than or equal to condition
* @summary Builds a condition that checks if the attribute is less than or equal to the specified value
* @param {any} val - The value to compare the attribute against
* @return {Condition<M>} A new condition representing the less than or equal comparison
*/
lte(val) {
return this.setOp(constants_1.Operator.SMALLER_EQ, val);
}
/**
* @description Creates an inclusion condition
* @summary Builds a condition that checks if the attribute value is included in the specified array
* @param {any[]} arr - The array of values to check against
* @return {Condition<M>} A new condition representing the inclusion comparison
*/
in(arr) {
return this.setOp(constants_1.Operator.IN, arr);
}
/**
* @description Creates a regular expression condition
* @summary Builds a condition that checks if the attribute matches the specified regular expression pattern
* @param {any} val - The regular expression pattern to match against
* @return {Condition<M>} A new condition representing the regular expression comparison
*/
regexp(val) {
return this.setOp(constants_1.Operator.REGEXP, new RegExp(val).source);
}
/**
* @description Sets the operator and comparison value for the condition
* @summary Private method that configures the condition with the specified operator and value
* @param {Operator} op - The operator to use for the condition
* @param {any} val - The value to compare against
* @return {Condition<M>} A new condition with the specified operator and value
*/
setOp(op, val) {
this.operator = op;
this.comparison = val;
return this.build();
}
/**
* @description Constructs a Condition instance from the builder's state
* @summary Finalizes the condition building process by creating a new Condition instance
* @throws {QueryError} If the condition cannot be built due to invalid parameters
* @return {Condition<M>} A new condition instance with the configured attributes
*/
build() {
try {
return new Condition(this.attr1, this.operator, this.comparison);
}
catch (e) {
throw new errors_1.QueryError(e);
}
}
}; }
/**
* @description Creates a new condition builder
* @summary Factory method that returns a new instance of the condition builder
* @template M - The model type this condition builder will operate on
* @return {ConditionBuilderOption<M>} A new condition builder instance
*/
static builder() {
return new Condition.Builder();
}
}
exports.Condition = Condition;
__decorate([
(0, decorator_validation_1.required)(),
__metadata("design:type", Object)
], Condition.prototype, "attr1", void 0);
__decorate([
(0, decorator_validation_1.required)(),
__metadata("design:type", String)
], Condition.prototype, "operator", void 0);
__decorate([
(0, decorator_validation_1.required)(),
__metadata("design:type", Object)
], Condition.prototype, "comparison", void 0);
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"Condition.js","sourceRoot":"","sources":["../../src/query/Condition.ts"],"names":[],"mappings":"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","sourcesContent":["import { AttributeOption, ConditionBuilderOption } from \"./options\";\nimport {\n  ConditionalAsync,\n  Model,\n  ModelErrorDefinition,\n  required,\n} from \"@decaf-ts/decorator-validation\";\nimport { GroupOperator, Operator } from \"./constants\";\nimport { QueryError } from \"./errors\";\n\ntype InferAsync<M> = M extends Model<infer A> ? A : false;\n\n/**\n * @description Represents a logical condition for database queries\n * @summary A class that encapsulates query conditions with support for complex logical operations.\n * This class allows for building and combining query conditions using logical operators (AND, OR, NOT)\n * and comparison operators (equals, not equals, greater than, etc.).\n * @template M - The model type this condition operates on\n * @param {string | Condition<M>} attr1 - The attribute name or a nested condition\n * @param {Operator | GroupOperator} operator - The operator to use for the condition\n * @param {any} comparison - The value to compare against or another condition\n * @class Condition\n * @example\n * // Create a simple condition\n * const nameCondition = Condition.attribute(\"name\").eq(\"John\");\n *\n * // Create a complex condition\n * const complexCondition = Condition.attribute(\"age\").gt(18)\n *   .and(Condition.attribute(\"status\").eq(\"active\"));\n *\n * // Use the builder pattern\n * const userQuery = Condition.builder()\n *   .attribute(\"email\").regexp(\".*@example.com\")\n *   .and(Condition.attribute(\"lastLogin\").gt(new Date(\"2023-01-01\")));\n */\nexport class Condition<M extends Model<any>> extends Model<InferAsync<M>> {\n  @required()\n  protected attr1?: string | Condition<M> = undefined;\n  @required()\n  protected operator?: Operator | GroupOperator = undefined;\n  @required()\n  protected comparison?: any = undefined;\n\n  private constructor(\n    attr1: string | Condition<M>,\n    operator: Operator | GroupOperator,\n    comparison: any\n  ) {\n    super();\n    this.attr1 = attr1;\n    this.operator = operator;\n    this.comparison = comparison;\n  }\n\n  /**\n   * @description Combines this condition with another using logical AND\n   * @summary Joins two conditions with an AND operator, requiring both to be true\n   * @param {Condition<M>} condition - The condition to combine with this one\n   * @return {Condition<M>} A new condition representing the AND operation\n   */\n  and(condition: Condition<M>): Condition<M> {\n    return Condition.and(this, condition);\n  }\n\n  /**\n   * @description Combines this condition with another using logical OR\n   * @summary Joins two conditions with an OR operator, requiring at least one to be true\n   * @param {Condition<M>} condition - The condition to combine with this one\n   * @return {Condition<M>} A new condition representing the OR operation\n   */\n  or(condition: Condition<M>): Condition<M> {\n    return Condition.or(this, condition);\n  }\n\n  /**\n   * @description Creates a negation condition\n   * @summary Excludes a value from the result by applying a NOT operator\n   * @param {any} val - The value to negate\n   * @return {Condition<M>} A new condition representing the NOT operation\n   */\n  not(val: any): Condition<M> {\n    return new Condition(this, Operator.NOT, val);\n  }\n\n  /**\n   * @description Validates the condition and checks for errors\n   * @summary Extends the base validation to ensure the condition is properly formed\n   * @param {...string[]} exceptions - Fields to exclude from validation\n   * @return {ModelErrorDefinition | undefined} Error definition if validation fails, undefined otherwise\n   */\n  override hasErrors(\n    ...exceptions: string[]\n  ): ConditionalAsync<InferAsync<M>, ModelErrorDefinition | undefined> {\n    const conditionCheck = (): ModelErrorDefinition | undefined => {\n      const invalidOpMessage = `Invalid operator ${this.operator}}`;\n\n      if (typeof this.attr1 === \"string\") {\n        if (this.comparison instanceof Condition)\n          return {\n            comparison: {\n              condition:\n                \"Both sides of the comparison must be of the same type\",\n            },\n          } as ModelErrorDefinition;\n        if (Object.values(Operator).indexOf(this.operator as Operator) === -1)\n          return {\n            operator: {\n              condition: invalidOpMessage,\n            },\n          } as ModelErrorDefinition;\n      }\n\n      if (this.attr1 instanceof Condition) {\n        if (\n          !(this.comparison instanceof Condition) &&\n          this.operator !== Operator.NOT\n        )\n          return {\n            comparison: {\n              condition: invalidOpMessage,\n            },\n          } as ModelErrorDefinition;\n        if (\n          Object.values(GroupOperator).indexOf(\n            this.operator as GroupOperator\n          ) === -1 &&\n          this.operator !== Operator.NOT\n        )\n          return {\n            operator: {\n              condition: invalidOpMessage,\n            },\n          } as ModelErrorDefinition;\n      }\n    };\n\n    const errors = super.hasErrors(...exceptions);\n    if (!this.isAsync())\n      return (\n        (errors as ModelErrorDefinition | undefined) ??\n        (conditionCheck() as any)\n      );\n\n    return (async () => {\n      const resolved = await Promise.resolve(\n        errors as unknown as Promise<ModelErrorDefinition | undefined>\n      );\n      return resolved ?? conditionCheck();\n    })() as ConditionalAsync<InferAsync<M>, ModelErrorDefinition | undefined>;\n  }\n\n  /**\n   * @description Creates a new condition that combines two conditions with logical AND\n   * @summary Static method that joins two conditions with an AND operator, requiring both to be true\n   * @template M - The model type this condition operates on\n   * @param {Condition<M>} condition1 - The first condition\n   * @param {Condition<M>} condition2 - The second condition\n   * @return {Condition<M>} A new condition representing the AND operation\n   */\n  static and<M extends Model>(\n    condition1: Condition<M>,\n    condition2: Condition<M>\n  ): Condition<M> {\n    return Condition.group(condition1, GroupOperator.AND, condition2);\n  }\n\n  /**\n   * @description Creates a new condition that combines two conditions with logical OR\n   * @summary Static method that joins two conditions with an OR operator, requiring at least one to be true\n   * @template M - The model type this condition operates on\n   * @param {Condition<M>} condition1 - The first condition\n   * @param {Condition<M>} condition2 - The second condition\n   * @return {Condition<M>} A new condition representing the OR operation\n   */\n  static or<M extends Model>(\n    condition1: Condition<M>,\n    condition2: Condition<M>\n  ): Condition<M> {\n    return Condition.group(condition1, GroupOperator.OR, condition2);\n  }\n\n  /**\n   * @description Creates a new condition that groups two conditions with a specified operator\n   * @summary Private static method that combines two conditions using the specified group operator\n   * @template M - The model type this condition operates on\n   * @param {Condition<M>} condition1 - The first condition\n   * @param {GroupOperator} operator - The group operator to use (AND, OR)\n   * @param {Condition<M>} condition2 - The second condition\n   * @return {Condition<M>} A new condition representing the grouped operation\n   */\n  private static group<M extends Model>(\n    condition1: Condition<M>,\n    operator: GroupOperator,\n    condition2: Condition<M>\n  ): Condition<M> {\n    return new Condition(condition1, operator, condition2);\n  }\n\n  /**\n   * @description Creates a condition builder for a specific model attribute\n   * @summary Static method that initializes a condition builder with the specified attribute\n   * @template M - The model type this condition operates on\n   * @param attr - The model attribute to build a condition for\n   * @return {AttributeOption<M>} A condition builder initialized with the attribute\n   */\n  static attribute<M extends Model>(attr: keyof M) {\n    return new Condition.Builder<M>().attribute(attr);\n  }\n\n  /**\n   * @description Alias for the attribute method\n   * @summary Shorthand method that initializes a condition builder with the specified attribute\n   * @template M - The model type this condition operates on\n   * @param attr - The model attribute to build a condition for\n   * @return {AttributeOption<M>} A condition builder initialized with the attribute\n   */\n  static attr<M extends Model>(attr: keyof M) {\n    return this.attribute(attr);\n  }\n\n  /**\n   * @description Provides a fluent API to build query conditions\n   * @summary A builder class that simplifies the creation of database query conditions\n   * with a chainable interface for setting attributes and operators\n   * @template M - The model type this condition builder operates on\n   * @class ConditionBuilder\n   */\n  private static Builder = class ConditionBuilder<M extends Model>\n    implements ConditionBuilderOption<M>, AttributeOption<M>\n  {\n    attr1?: keyof M | Condition<M> = undefined;\n    operator?: Operator | GroupOperator = undefined;\n    comparison?: any = undefined;\n\n    /**\n     * @description Sets the attribute for the condition\n     * @summary Specifies which model attribute the condition will operate on\n     * @param attr - The model attribute to use in the condition\n     * @return {AttributeOption<M>} This builder instance for method chaining\n     */\n    attribute(attr: keyof M): AttributeOption<M> {\n      this.attr1 = attr;\n      return this;\n    }\n\n    /**\n     * @description Alias for the attribute method\n     * @summary Shorthand method to specify which model attribute the condition will operate on\n     * @param attr - The model attribute to use in the condition\n     * @return {AttributeOption<M>} This builder instance for method chaining\n     */\n    attr(attr: keyof M) {\n      return this.attribute(attr);\n    }\n\n    /**\n     * @description Creates an equality condition\n     * @summary Builds a condition that checks if the attribute equals the specified value\n     * @param {any} val - The value to compare the attribute against\n     * @return {Condition<M>} A new condition representing the equality comparison\n     */\n    eq(val: any) {\n      return this.setOp(Operator.EQUAL, val);\n    }\n\n    /**\n     * @description Creates an inequality condition\n     * @summary Builds a condition that checks if the attribute is different from the specified value\n     * @param {any} val - The value to compare the attribute against\n     * @return {Condition<M>} A new condition representing the inequality comparison\n     */\n    dif(val: any) {\n      return this.setOp(Operator.DIFFERENT, val);\n    }\n\n    /**\n     * @description Creates a greater than condition\n     * @summary Builds a condition that checks if the attribute is greater than the specified value\n     * @param {any} val - The value to compare the attribute against\n     * @return {Condition<M>} A new condition representing the greater than comparison\n     */\n    gt(val: any) {\n      return this.setOp(Operator.BIGGER, val);\n    }\n\n    /**\n     * @description Creates a less than condition\n     * @summary Builds a condition that checks if the attribute is less than the specified value\n     * @param {any} val - The value to compare the attribute against\n     * @return {Condition<M>} A new condition representing the less than comparison\n     */\n    lt(val: any) {\n      return this.setOp(Operator.SMALLER, val);\n    }\n\n    /**\n     * @description Creates a greater than or equal to condition\n     * @summary Builds a condition that checks if the attribute is greater than or equal to the specified value\n     * @param {any} val - The value to compare the attribute against\n     * @return {Condition<M>} A new condition representing the greater than or equal comparison\n     */\n    gte(val: any) {\n      return this.setOp(Operator.BIGGER_EQ, val);\n    }\n\n    /**\n     * @description Creates a less than or equal to condition\n     * @summary Builds a condition that checks if the attribute is less than or equal to the specified value\n     * @param {any} val - The value to compare the attribute against\n     * @return {Condition<M>} A new condition representing the less than or equal comparison\n     */\n    lte(val: any) {\n      return this.setOp(Operator.SMALLER_EQ, val);\n    }\n\n    /**\n     * @description Creates an inclusion condition\n     * @summary Builds a condition that checks if the attribute value is included in the specified array\n     * @param {any[]} arr - The array of values to check against\n     * @return {Condition<M>} A new condition representing the inclusion comparison\n     */\n    in(arr: any[]) {\n      return this.setOp(Operator.IN, arr);\n    }\n\n    /**\n     * @description Creates a regular expression condition\n     * @summary Builds a condition that checks if the attribute matches the specified regular expression pattern\n     * @param {any} val - The regular expression pattern to match against\n     * @return {Condition<M>} A new condition representing the regular expression comparison\n     */\n    regexp(val: any) {\n      return this.setOp(Operator.REGEXP, new RegExp(val).source);\n    }\n\n    /**\n     * @description Sets the operator and comparison value for the condition\n     * @summary Private method that configures the condition with the specified operator and value\n     * @param {Operator} op - The operator to use for the condition\n     * @param {any} val - The value to compare against\n     * @return {Condition<M>} A new condition with the specified operator and value\n     */\n    private setOp(op: Operator, val: any) {\n      this.operator = op;\n      this.comparison = val;\n      return this.build();\n    }\n\n    /**\n     * @description Constructs a Condition instance from the builder's state\n     * @summary Finalizes the condition building process by creating a new Condition instance\n     * @throws {QueryError} If the condition cannot be built due to invalid parameters\n     * @return {Condition<M>} A new condition instance with the configured attributes\n     */\n    private build(): Condition<M> {\n      try {\n        return new Condition(\n          this.attr1 as string | Condition<M>,\n          this.operator as Operator,\n          this.comparison as any\n        );\n      } catch (e: any) {\n        throw new QueryError(e);\n      }\n    }\n  };\n\n  /**\n   * @description Creates a new condition builder\n   * @summary Factory method that returns a new instance of the condition builder\n   * @template M - The model type this condition builder will operate on\n   * @return {ConditionBuilderOption<M>} A new condition builder instance\n   */\n  static builder<M extends Model>(): ConditionBuilderOption<M> {\n    return new Condition.Builder<M>();\n  }\n}\n"]}