rads-db 3.0.78 → 3.0.80

package/dist/index.cjs

@@ -888,7 +888,7 @@ function getRadsDbMethods(key, computedContext, driverInstance) {
       result2.id = uuid.v4();
     for (const [fieldName, field] of Object.entries(type.fields)) {
       if (field.defaultValue)
-        result2[fieldName] = field.defaultValue;
+        result2[fieldName] = ___default.cloneDeep(field.defaultValue);
       if (field.defaultValueClass)
         result2[fieldName] = construct(field.defaultValueClass);
     }

package/dist/index.mjs

@@ -881,7 +881,7 @@ function getRadsDbMethods(key, computedContext, driverInstance) {
       result2.id = v4();
     for (const [fieldName, field] of Object.entries(type.fields)) {
       if (field.defaultValue)
-        result2[fieldName] = field.defaultValue;
+        result2[fieldName] = _.cloneDeep(field.defaultValue);
       if (field.defaultValueClass)
         result2[fieldName] = construct(field.defaultValueClass);
     }

package/integrations/lib.cjs

@@ -152,13 +152,13 @@ function getOrder(f) {
   };
   return decorator.order ?? defaultOrders[decorator.preset] ?? 0;
 }
-function parseClassOrTypeDeclaration(typeDeclaration, typeName, ctx) {
-  if (typeDeclaration.kind === _typescript.SyntaxKind.ClassDeclaration) return parseClassDeclaration(typeDeclaration, typeName, ctx);
-  if (typeDeclaration.kind === _typescript.SyntaxKind.TypeAliasDeclaration) return parseTypeAliasDeclaration(typeDeclaration, typeName, ctx);
+function parseClassOrTypeDeclaration(typeDeclaration, typeName, ctx2) {
+  if (typeDeclaration.kind === _typescript.SyntaxKind.ClassDeclaration) return parseClassDeclaration(typeDeclaration, typeName, ctx2);
+  if (typeDeclaration.kind === _typescript.SyntaxKind.TypeAliasDeclaration) return parseTypeAliasDeclaration(typeDeclaration, typeName, ctx2);
   throw new Error(`Unexpected type definition - ${typeName}`);
 }
-function parseClassDeclaration(typeDeclaration, typeName, ctx) {
-  if (ctx.result[typeName]) return ctx.result[typeName];
+function parseClassDeclaration(typeDeclaration, typeName, ctx2) {
+  if (ctx2.result[typeName]) return ctx2.result[typeName];
   const {
     modifiers
   } = typeDeclaration;
@@ -166,7 +166,7 @@ function parseClassDeclaration(typeDeclaration, typeName, ctx) {
   if (!nameNode || nameNode.kind !== _typescript.SyntaxKind.Identifier) throw new Error("Cannot detect class name");
   const name = nameNode.text;
   const comment = getCommentFromJsdocNode(typeDeclaration.jsDoc);
-  const decorators = parseDecorators(modifiers, ctx);
+  const decorators = parseDecorators(modifiers, ctx2);
   const classDeclaration = typeDeclaration;
   const {
     members,
@@ -176,12 +176,12 @@ function parseClassDeclaration(typeDeclaration, typeName, ctx) {
   const isExtending = isExtendingExpr?.text;
   for (const m of members) {
     if (m.kind !== _typescript.SyntaxKind.PropertyDeclaration) {
-      throw new Error(`Unexpected class member - only properties are allowed("${m.getText(ctx.sourceFile)}")`);
+      throw new Error(`Unexpected class member - only properties are allowed("${m.getText(ctx2.sourceFile)}")`);
     }
   }
   const fields = {};
   for (const m of members) {
-    const field = parseClassMember(m, fields, name, ctx);
+    const field = parseClassMember(m, fields, name, ctx2);
     fields[field.name] = field;
   }
   const handle = _lodash.default.lowerFirst(name);
@@ -194,12 +194,12 @@ function parseClassDeclaration(typeDeclaration, typeName, ctx) {
     fields,
     isExtending,
     comment,
-    sourceFile: ctx.sourceFile.fileName
+    sourceFile: ctx2.sourceFile.fileName
   };
   return result;
 }
-function parseTypeAliasDeclaration(typeDeclaration, typeName, ctx) {
-  if (ctx.result[typeName]) return ctx.result[typeName];
+function parseTypeAliasDeclaration(typeDeclaration, typeName, ctx2) {
+  if (ctx2.result[typeName]) return ctx2.result[typeName];
   const nameNode = typeDeclaration.name;
   if (!nameNode || nameNode.kind !== _typescript.SyntaxKind.Identifier) throw new Error("Cannot detect class name");
   const name = nameNode.text;
@@ -208,72 +208,72 @@ function parseTypeAliasDeclaration(typeDeclaration, typeName, ctx) {
   const typeAliasType = typeAliasDeclaration.type;
   if (typeAliasType.kind === _typescript.SyntaxKind.UnionType) {
     const typeAliasValue = typeAliasDeclaration.type;
-    const enumValues = getEnumValues(typeAliasValue, typeDeclaration, ctx);
+    const enumValues = getEnumValues(typeAliasValue, typeDeclaration, ctx2);
     return {
       name,
       enumValues,
       comment,
       decorators: {},
-      sourceFile: ctx.sourceFile.fileName
+      sourceFile: ctx2.sourceFile.fileName
     };
   }
   if (typeAliasType.kind === _typescript.SyntaxKind.TypeOperator && typeAliasType.operator === _typescript.SyntaxKind.KeyOfKeyword) {
-    const enumValues = getEnumValuesFromKeyOf(typeAliasType, ctx);
+    const enumValues = getEnumValuesFromKeyOf(typeAliasType, ctx2);
     return {
       name,
       enumValues,
       comment,
       decorators: {},
-      sourceFile: ctx.sourceFile.fileName
+      sourceFile: ctx2.sourceFile.fileName
     };
   }
-  throw new Error(`Unexpected type definition - ${typeDeclaration.getText(ctx.sourceFile)}. Did you mean 'class'?`);
+  throw new Error(`Unexpected type definition - ${typeDeclaration.getText(ctx2.sourceFile)}. Did you mean 'class'?`);
 }
-function parseDecorators(modifiers, ctx) {
+function parseDecorators(modifiers, ctx2) {
   if (!modifiers) return {};
   const decoratorNodes = modifiers?.filter(x => x.kind === _typescript.SyntaxKind.Decorator) || [];
-  const decoratorsArray = decoratorNodes?.map(x => parseDecorator(x, ctx)) || [];
+  const decoratorsArray = decoratorNodes?.map(x => parseDecorator(x, ctx2)) || [];
   const decorators = {};
   for (const d of decoratorsArray) {
     decorators[d.name] = d.args;
   }
   return decorators;
 }
-function getEnumValues(node, parentNode, ctx) {
+function getEnumValues(node, parentNode, ctx2) {
   const enumValuesArray = node.types.map(node2 => {
     if (node2.kind !== _typescript.SyntaxKind.LiteralType) {
-      throw new Error(`Unexpected type definition - ${parentNode.getText(ctx.sourceFile)}`);
+      throw new Error(`Unexpected type definition - ${parentNode.getText(ctx2.sourceFile)}`);
     }
     const {
       literal
     } = node2;
-    if (literal.kind !== _typescript.SyntaxKind.StringLiteral) throw new Error(`Unexpected type definition - ${parentNode.getText(ctx.sourceFile)}`);
+    if (literal.kind !== _typescript.SyntaxKind.StringLiteral) throw new Error(`Unexpected type definition - ${parentNode.getText(ctx2.sourceFile)}`);
     return {
       name: literal.text
     };
   });
   return _lodash.default.keyBy(enumValuesArray, "name");
 }
-function parseClassMember(node, parentFields, parentName, ctx) {
-  const name = node.name.getText(ctx.sourceFile);
+function parseClassMember(node, parentFields, parentName, ctx2) {
+  const name = node.name.getText(ctx2.sourceFile);
   const {
-    defaultValue,
+    defaultValue: defaultValue2,
     defaultValueCopyFrom,
     defaultValueClass
-  } = parseDefaultValueExpression(node.initializer, ctx);
+  } = parseDefaultValueExpression(node.initializer, ctx2);
   const isRequired = !node.questionToken;
   const comment = getCommentFromJsdocNode(node.jsDoc);
-  const decorators = parseDecorators(node.modifiers, ctx);
-  let defaultValueType = defaultValueClass || getPrimitiveTypeFromDefaultValue(defaultValue);
+  const decorators = parseDecorators(node.modifiers, ctx2);
+  let defaultValueType = defaultValueClass || getPrimitiveTypeFromDefaultValue(defaultValue2);
   if (defaultValueCopyFrom) {
     const parentField = parentFields[defaultValueCopyFrom];
     if (!parentField) throw new Error(`Cannot find field ${parentName}.${defaultValueCopyFrom}"`);
     defaultValueType = parentField.type;
   }
-  const parsedType = parseFieldType(ctx, parentName, name, node, defaultValueType);
+  const parsedType = parseFieldType(ctx2, parentName, name, node, defaultValueType);
   const result = {
     ...parsedType,
-    defaultValue,
+    defaultValue: defaultValue2,
     defaultValueCopyFrom,
     name,
     isRequired,
@@ -297,7 +297,7 @@ function getPrimitiveTypeFromDefaultValue(value) {
   if (_lodash.default.isObject(value)) return "object";
   return void 0;
 }
-function parseFieldType(ctx, parentName, fieldName, node, defaultValueType) {
+function parseFieldType(ctx2, parentName, fieldName, node, defaultValueType) {
   const parsedType = {
     isArray: false,
     isRelation: false,
@@ -308,19 +308,19 @@ function parseFieldType(ctx, parentName, fieldName, node, defaultValueType) {
     node
   };
   parseFieldTypeArray(parsedType, parentName);
-  parseFieldTypeRelation(parsedType, parentName, ctx);
-  parseFieldTypeInverseRelation(parsedType, parentName, ctx);
-  parseFieldTypeInlineEnum(parsedType, parentName, fieldName, ctx);
-  parseFieldTypeKeyofEnum(parsedType, parentName, fieldName, ctx);
-  parseFieldTypeRecordEnum(parsedType, parentName, fieldName, ctx);
-  parsedType.type = parsedType.type ?? parsedType.nodeType?.getText(ctx.sourceFile) ?? defaultValueType;
-  if (!parsedType.type) throw new Error(`Cannot detect property type: '${node.getText(ctx.sourceFile)}'`);
+  parseFieldTypeRelation(parsedType, parentName, ctx2);
+  parseFieldTypeInverseRelation(parsedType, parentName, ctx2);
+  parseFieldTypeInlineEnum(parsedType, parentName, fieldName, ctx2);
+  parseFieldTypeKeyofEnum(parsedType, parentName, fieldName, ctx2);
+  parseFieldTypeRecordEnum(parsedType, parentName, fieldName, ctx2);
+  parsedType.type = parsedType.type ?? parsedType.nodeType?.getText(ctx2.sourceFile) ?? defaultValueType;
+  if (!parsedType.type) throw new Error(`Cannot detect property type: '${node.getText(ctx2.sourceFile)}'`);
   if (parsedType.type.startsWith("Change<")) {
     parsedType.type = parsedType.type.slice(7, -1);
-    if (!ctx.typeNodesMap[parsedType.type]) throw new Error(`Unexpected property type: '${parsedType.type}'`);
+    if (!ctx2.typeNodesMap[parsedType.type]) throw new Error(`Unexpected property type: '${parsedType.type}'`);
     parsedType.isChange = true;
   } else {
-    if (!supportedPrimitiveTypes.includes(parsedType.type) && !ctx.typeNodesMap[parsedType.type] && !ctx.result[parsedType.type]) {
+    if (!supportedPrimitiveTypes.includes(parsedType.type) && !ctx2.typeNodesMap[parsedType.type] && !ctx2.result[parsedType.type]) {
       throw new Error(`Unexpected property type: '${parsedType.type}'`);
     }
   }
@@ -334,17 +334,17 @@ function parseFieldType(ctx, parentName, fieldName, node, defaultValueType) {
     type: parsedType.type
   };
 }
-function parseFieldTypeRecordEnum(parsedType, parentName, fieldName, ctx) {
+function parseFieldTypeRecordEnum(parsedType, parentName, fieldName, ctx2) {
   if (parsedType.nodeType?.kind !== _typescript.SyntaxKind.TypeReference) return;
   const nt = parsedType.nodeType;
-  if (nt.typeName.getText(ctx.sourceFile) !== "Record") return;
+  if (nt.typeName.getText(ctx2.sourceFile) !== "Record") return;
   if (nt.typeArguments?.length !== 2) return;
-  const keyTypeName = nt.typeArguments[0].getText(ctx.sourceFile);
-  const valueTypeName = nt.typeArguments[1].getText(ctx.sourceFile);
-  const keyType = ctx.typeNodesMap[keyTypeName];
+  const keyTypeName = nt.typeArguments[0].getText(ctx2.sourceFile);
+  const valueTypeName = nt.typeArguments[1].getText(ctx2.sourceFile);
+  const keyType = ctx2.typeNodesMap[keyTypeName];
   if (!keyType) return;
-  if (!ctx.result[keyTypeName]) ctx.result[keyTypeName] = parseClassOrTypeDeclaration(keyType.node, keyTypeName, ctx);
-  const enumValues = ctx.result[keyTypeName].enumValues;
+  if (!ctx2.result[keyTypeName]) ctx2.result[keyTypeName] = parseClassOrTypeDeclaration(keyType.node, keyTypeName, ctx2);
+  const enumValues = ctx2.result[keyTypeName].enumValues;
   if (!enumValues) throw new Error(`Unexpected type - ${keyTypeName}`);
   const newTypeName = `${parentName}_${_lodash.default.upperFirst(fieldName)}`;
   const fieldsArray = _lodash.default.values(enumValues).map(v => ({
@@ -352,11 +352,11 @@ function parseFieldTypeRecordEnum(parsedType, parentName, fieldName, ctx) {
     type: valueTypeName,
     isRequired: true
   }));
-  ctx.result[newTypeName] = {
+  ctx2.result[newTypeName] = {
     name: newTypeName,
     decorators: {},
     fields: _lodash.default.keyBy(fieldsArray, "name"),
-    sourceFile: ctx.sourceFile.fileName
+    sourceFile: ctx2.sourceFile.fileName
   };
   parsedType.type = newTypeName;
 }
@@ -371,126 +371,126 @@ function parseFieldTypeArray(parsedType, parentName) {
     throw new Error(`Nested arrays are not supported (${parentName})`);
   }
 }
-function parseFieldTypeRelation(parsedType, parentName, ctx) {
+function parseFieldTypeRelation(parsedType, parentName, ctx2) {
   if (parsedType.nodeType?.kind !== _typescript.SyntaxKind.TypeReference) return;
   const nt = parsedType.nodeType;
-  if (nt.typeName.getText(ctx.sourceFile) === "Relation") {
+  if (nt.typeName.getText(ctx2.sourceFile) === "Relation") {
     if (!nt.typeArguments?.length) throw new Error(`Missing type argument for Relation<>: '${parentName}'`);
     parsedType.nodeType = nt.typeArguments[0];
     parsedType.isRelation = true;
     if (nt.typeArguments[1]) {
       const ta = nt.typeArguments[1];
-      parsedType.relationDenormFields = getRelationDenormFields(ctx, ta);
+      parsedType.relationDenormFields = getRelationDenormFields(ctx2, ta);
     }
   }
 }
-function parseFieldTypeInverseRelation(parsedType, parentName, ctx) {
+function parseFieldTypeInverseRelation(parsedType, parentName, ctx2) {
   if (parsedType.nodeType?.kind !== _typescript.SyntaxKind.TypeReference) return;
   const nt = parsedType.nodeType;
-  if (nt.typeName.getText(ctx.sourceFile) === "InverseRelation") {
+  if (nt.typeName.getText(ctx2.sourceFile) === "InverseRelation") {
     if (!nt.typeArguments?.length) throw new Error(`Missing type argument for Relation<>: '${parentName}'`);
-    parsedType.type = parseStringField(ctx, nt.typeArguments[0]);
+    parsedType.type = parseStringField(ctx2, nt.typeArguments[0]);
     parsedType.isInverseRelation = true;
     if (nt.typeArguments[1]) {
       const taNode = nt.typeArguments[1];
-      parsedType.inverseRelationField = parseStringField(ctx, taNode);
+      parsedType.inverseRelationField = parseStringField(ctx2, taNode);
     }
   }
 }
-function parseStringField(ctx, node) {
+function parseStringField(ctx2, node) {
   if (node.kind === _typescript.SyntaxKind.LiteralType) {
     const literal = node.literal;
     if (literal.kind === _typescript.SyntaxKind.StringLiteral) {
       return literal.text;
     }
   }
-  throw new Error(`Unexpected type - ${node.getText(ctx.sourceFile)}`);
+  throw new Error(`Unexpected type - ${node.getText(ctx2.sourceFile)}`);
 }
-function parseFieldTypeInlineEnum(parsedType, parentName, fieldName, ctx) {
+function parseFieldTypeInlineEnum(parsedType, parentName, fieldName, ctx2) {
   if (parsedType.nodeType?.kind !== _typescript.SyntaxKind.UnionType) return;
   const nt = parsedType.nodeType;
-  const enumValues = getEnumValues(nt, parsedType.node, ctx);
+  const enumValues = getEnumValues(nt, parsedType.node, ctx2);
   const newTypeName = `${parentName}_${_lodash.default.upperFirst(fieldName)}`;
-  ctx.result[newTypeName] = {
+  ctx2.result[newTypeName] = {
     name: newTypeName,
     decorators: {},
     enumValues,
-    sourceFile: ctx.sourceFile.fileName
+    sourceFile: ctx2.sourceFile.fileName
   };
   parsedType.type = newTypeName;
 }
-function parseFieldTypeKeyofEnum(parsedType, parentName, fieldName, ctx) {
+function parseFieldTypeKeyofEnum(parsedType, parentName, fieldName, ctx2) {
   if (parsedType.nodeType?.kind !== _typescript.SyntaxKind.TypeOperator) return;
   const nt = parsedType.nodeType;
   if (nt.operator !== _typescript.SyntaxKind.KeyOfKeyword) return;
-  const enumValues = getEnumValuesFromKeyOf(nt, ctx);
+  const enumValues = getEnumValuesFromKeyOf(nt, ctx2);
   const newTypeName = `${parentName}_${_lodash.default.upperFirst(fieldName)}`;
-  ctx.result[newTypeName] = {
+  ctx2.result[newTypeName] = {
     name: newTypeName,
     decorators: {},
     enumValues,
-    sourceFile: ctx.sourceFile.fileName
+    sourceFile: ctx2.sourceFile.fileName
   };
   parsedType.type = newTypeName;
 }
-function getEnumValuesFromKeyOf(nodeType, ctx) {
+function getEnumValuesFromKeyOf(nodeType, ctx2) {
   if (nodeType.type.kind !== _typescript.SyntaxKind.TypeReference) {
-    throw new Error(`Unexpected type - ${nodeType.type.getText(ctx.sourceFile)}`);
+    throw new Error(`Unexpected type - ${nodeType.type.getText(ctx2.sourceFile)}`);
   }
   const typeReferenceNode = nodeType.type;
   if (typeReferenceNode.typeName.kind !== _typescript.SyntaxKind.Identifier) {
-    throw new Error(`Unexpected type - ${typeReferenceNode.getText(ctx.sourceFile)}`);
+    throw new Error(`Unexpected type - ${typeReferenceNode.getText(ctx2.sourceFile)}`);
   }
   const typeName = typeReferenceNode.typeName.text;
-  const type = ctx.typeNodesMap[typeName];
+  const type = ctx2.typeNodesMap[typeName];
   if (!type) {
     throw new Error(`Unexpected type - ${typeName}`);
   }
-  if (!ctx.result[typeName]) ctx.result[typeName] = parseClassOrTypeDeclaration(type.node, typeName, ctx);
-  if (!ctx.result[typeName].fields) throw new Error(`Unexpected type - ${typeName}`);
-  return _lodash.default.mapValues(ctx.result[typeName].fields || {}, v => ({
+  if (!ctx2.result[typeName]) ctx2.result[typeName] = parseClassOrTypeDeclaration(type.node, typeName, ctx2);
+  if (!ctx2.result[typeName].fields) throw new Error(`Unexpected type - ${typeName}`);
+  return _lodash.default.mapValues(ctx2.result[typeName].fields || {}, v => ({
     name: v.name,
     comment: v.comment,
     decorators: v.decorators
   }));
 }
-function getRelationDenormFields(ctx, node) {
+function getRelationDenormFields(ctx2, node) {
   if (node.kind === _typescript.SyntaxKind.LiteralType) {
     const literal = node.literal;
     if (literal.kind === _typescript.SyntaxKind.StringLiteral) {
       return [literal.text];
     }
-    throw new Error(`Unexpected type - ${literal.getText(ctx.sourceFile)}`);
+    throw new Error(`Unexpected type - ${literal.getText(ctx2.sourceFile)}`);
   }
   if (node.kind === _typescript.SyntaxKind.UnionType) {
     const union = node;
-    return union.types.flatMap(t => getRelationDenormFields(ctx, t));
+    return union.types.flatMap(t => getRelationDenormFields(ctx2, t));
   }
-  throw new Error(`Unexpected type - ${node.getText(ctx.sourceFile)}`);
+  throw new Error(`Unexpected type - ${node.getText(ctx2.sourceFile)}`);
 }
-function verifyDefaultValueType(field, ctx) {
+function verifyDefaultValueType(field, ctx2) {
   const {
     isArray,
-    defaultValue,
+    defaultValue: defaultValue2,
     type
   } = field;
   if (isArray) {
-    if (!_lodash.default.isArray(defaultValue)) {
+    if (!_lodash.default.isArray(defaultValue2)) {
       throw new TypeError(`Default value type is different from field type: '${type}'`);
     }
   } else {
-    if (supportedPrimitiveTypes.includes(type) && getPrimitiveTypeFromDefaultValue(defaultValue) !== type) {
+    if (supportedPrimitiveTypes.includes(type) && getPrimitiveTypeFromDefaultValue(defaultValue2) !== type) {
       throw new Error(`Default value type is different from field type: '${type}'`);
     }
-    if (!ctx.result[type] && ctx.typeNodesMap[type]) ctx.result[type] = parseClassOrTypeDeclaration(ctx.typeNodesMap[type].node, type, ctx);
-    const enumValues = ctx.result[type]?.enumValues;
-    if (enumValues && !enumValues[defaultValue]) {
+    if (!ctx2.result[type] && ctx2.typeNodesMap[type]) ctx2.result[type] = parseClassOrTypeDeclaration(ctx2.typeNodesMap[type].node, type, ctx2);
+    const enumValues = ctx2.result[type]?.enumValues;
+    if (enumValues && !enumValues[defaultValue2]) {
       const enumValuesStr = _lodash.default.keys(enumValues).map(x => `'x'`).join(", ");
       throw new Error(`Default value must be one of: ${enumValuesStr}`);
     }
   }
 }
-function verifyDefaultValueTypeCopyFrom(field, sourceField, ctx) {
+function verifyDefaultValueTypeCopyFrom(field, sourceField, ctx2) {
   const {
     isArray,
     type
@@ -505,27 +505,27 @@ function verifyDefaultValueTypeCopyFrom(field, sourceField, ctx) {
     }
   }
 }
-function parseDecorator(decoratorNode, ctx) {
-  const expr = decoratorNode.expression;
-  if (expr.kind !== _typescript.SyntaxKind.CallExpression) throw new Error(`Unexpected decorator format: "${expr.getText(ctx.sourceFile)}"`);
-  const nameNode = expr.expression;
-  if (nameNode.kind !== _typescript.SyntaxKind.Identifier) throw new Error(`Unexpected decorator format: "${nameNode.getText(ctx.sourceFile)}"`);
+function parseDecorator(decoratorNode, ctx2) {
+  const expr2 = decoratorNode.expression;
+  if (expr2.kind !== _typescript.SyntaxKind.CallExpression) throw new Error(`Unexpected decorator format: "${expr2.getText(ctx2.sourceFile)}"`);
+  const nameNode = expr2.expression;
+  if (nameNode.kind !== _typescript.SyntaxKind.Identifier) throw new Error(`Unexpected decorator format: "${nameNode.getText(ctx2.sourceFile)}"`);
   return {
     name: nameNode.text,
-    args: parseDecoratorArguments(expr, ctx)
+    args: parseDecoratorArguments(expr2, ctx2)
   };
 }
-function parseDecoratorArguments(expr, ctx) {
-  const args = expr.arguments;
+function parseDecoratorArguments(expr2, ctx2) {
+  const args = expr2.arguments;
   if (args.length === 0) return {};
-  if (args.length > 1) throw new Error(`Too many arguments - one expected: "${expr.getText(ctx.sourceFile)}"`);
+  if (args.length > 1) throw new Error(`Too many arguments - one expected: "${expr2.getText(ctx2.sourceFile)}"`);
   const arg = args[0];
-  return parseLiteralNode(arg, ctx) ?? {};
+  return parseLiteralNode(arg, ctx2) ?? {};
 }
-function parseDefaultValueExpression(expr, ctx) {
-  if (!expr) return {};
-  if (expr.kind === _typescript.SyntaxKind.NewExpression) {
-    const identifier = expr.expression;
+function parseDefaultValueExpression(expr2, ctx2) {
+  if (!expr2) return {};
+  if (expr2.kind === _typescript.SyntaxKind.NewExpression) {
+    const identifier = expr2.expression;
     const type = identifier?.text;
     if (type) {
       return {
@@ -533,13 +533,13 @@ function parseDefaultValueExpression(expr, ctx) {
         defaultValue: {}
       };
     }
-  } else if (expr.kind === _typescript.SyntaxKind.PropertyAccessExpression && expr.expression.kind === _typescript.SyntaxKind.ThisKeyword) {
+  } else if (expr2.kind === _typescript.SyntaxKind.PropertyAccessExpression && expr2.expression.kind === _typescript.SyntaxKind.ThisKeyword) {
     return {
-      defaultValueCopyFrom: expr.name?.text
+      defaultValueCopyFrom: expr2.name?.text
     };
   }
   return {
-    defaultValue: parseLiteralNode(expr, ctx)
+    defaultValue: parseLiteralNode(expr2, ctx2)
   };
 }
 function parseLiteralNode(expr, ctx) {
@@ -553,7 +553,7 @@ function parseLiteralNode(expr, ctx) {
     const defaultValueStr = expr.getText(ctx.sourceFile);
     let defaultValue;
     try {
-      defaultValue = JSON.parse(defaultValueStr.replace(/[\'\`]/gi, '"'));
+      defaultValue = eval(defaultValueStr);
     } catch (e) {
       throw new Error("Value must be valid array");
     }
@@ -562,16 +562,16 @@ function parseLiteralNode(expr, ctx) {
   }
   throw new Error(`Unexpected property expression: "${expr.getText(ctx.sourceFile)}"`);
 }
-function parseObjectLiteral(arg, ctx) {
+function parseObjectLiteral(arg, ctx2) {
   const result = {};
   for (const p of arg.properties) {
-    if (!p.name || ![_typescript.SyntaxKind.Identifier, _typescript.SyntaxKind.StringLiteral].includes(p.name.kind)) throw new Error(`Unexpected property name: "${p.getText(ctx.sourceFile)}"`);
+    if (!p.name || ![_typescript.SyntaxKind.Identifier, _typescript.SyntaxKind.StringLiteral].includes(p.name.kind)) throw new Error(`Unexpected property name: "${p.getText(ctx2.sourceFile)}"`);
     const nameNode = p.name;
     const name = nameNode.text;
-    if (p.kind !== _typescript.SyntaxKind.PropertyAssignment) throw new Error(`Unexpected property value: "${p.getText(ctx.sourceFile)}"`);
+    if (p.kind !== _typescript.SyntaxKind.PropertyAssignment) throw new Error(`Unexpected property value: "${p.getText(ctx2.sourceFile)}"`);
     const p2 = p;
     const valueExpression = p2.initializer;
-    const value = parseLiteralNode(valueExpression, ctx);
+    const value = parseLiteralNode(valueExpression, ctx2);
     result[name] = value;
   }
   return result;

package/integrations/lib.mjs

@@ -130,35 +130,35 @@ function getOrder(f) {
   };
   return decorator.order ?? defaultOrders[decorator.preset] ?? 0;
 }
-function parseClassOrTypeDeclaration(typeDeclaration, typeName, ctx) {
+function parseClassOrTypeDeclaration(typeDeclaration, typeName, ctx2) {
   if (typeDeclaration.kind === SyntaxKind.ClassDeclaration)
-    return parseClassDeclaration(typeDeclaration, typeName, ctx);
+    return parseClassDeclaration(typeDeclaration, typeName, ctx2);
   if (typeDeclaration.kind === SyntaxKind.TypeAliasDeclaration)
-    return parseTypeAliasDeclaration(typeDeclaration, typeName, ctx);
+    return parseTypeAliasDeclaration(typeDeclaration, typeName, ctx2);
   throw new Error(`Unexpected type definition - ${typeName}`);
 }
-function parseClassDeclaration(typeDeclaration, typeName, ctx) {
-  if (ctx.result[typeName])
-    return ctx.result[typeName];
+function parseClassDeclaration(typeDeclaration, typeName, ctx2) {
+  if (ctx2.result[typeName])
+    return ctx2.result[typeName];
   const { modifiers } = typeDeclaration;
   const nameNode = typeDeclaration.name;
   if (!nameNode || nameNode.kind !== SyntaxKind.Identifier)
     throw new Error("Cannot detect class name");
   const name = nameNode.text;
   const comment = getCommentFromJsdocNode(typeDeclaration.jsDoc);
-  const decorators = parseDecorators(modifiers, ctx);
+  const decorators = parseDecorators(modifiers, ctx2);
   const classDeclaration = typeDeclaration;
   const { members, heritageClauses } = classDeclaration;
   const isExtendingExpr = heritageClauses?.[0]?.types?.[0]?.expression;
   const isExtending = isExtendingExpr?.text;
   for (const m of members) {
     if (m.kind !== SyntaxKind.PropertyDeclaration) {
-      throw new Error(`Unexpected class member - only properties are allowed("${m.getText(ctx.sourceFile)}")`);
+      throw new Error(`Unexpected class member - only properties are allowed("${m.getText(ctx2.sourceFile)}")`);
     }
   }
   const fields = {};
   for (const m of members) {
-    const field = parseClassMember(m, fields, name, ctx);
+    const field = parseClassMember(m, fields, name, ctx2);
     fields[field.name] = field;
   }
   const handle = _.lowerFirst(name);
@@ -171,13 +171,13 @@ function parseClassDeclaration(typeDeclaration, typeName, ctx) {
     fields,
     isExtending,
     comment,
-    sourceFile: ctx.sourceFile.fileName
+    sourceFile: ctx2.sourceFile.fileName
   };
   return result;
 }
-function parseTypeAliasDeclaration(typeDeclaration, typeName, ctx) {
-  if (ctx.result[typeName])
-    return ctx.result[typeName];
+function parseTypeAliasDeclaration(typeDeclaration, typeName, ctx2) {
+  if (ctx2.result[typeName])
+    return ctx2.result[typeName];
   const nameNode = typeDeclaration.name;
   if (!nameNode || nameNode.kind !== SyntaxKind.Identifier)
     throw new Error("Cannot detect class name");
@@ -187,55 +187,55 @@ function parseTypeAliasDeclaration(typeDeclaration, typeName, ctx) {
   const typeAliasType = typeAliasDeclaration.type;
   if (typeAliasType.kind === SyntaxKind.UnionType) {
     const typeAliasValue = typeAliasDeclaration.type;
-    const enumValues = getEnumValues(typeAliasValue, typeDeclaration, ctx);
-    return { name, enumValues, comment, decorators: {}, sourceFile: ctx.sourceFile.fileName };
+    const enumValues = getEnumValues(typeAliasValue, typeDeclaration, ctx2);
+    return { name, enumValues, comment, decorators: {}, sourceFile: ctx2.sourceFile.fileName };
   }
   if (typeAliasType.kind === SyntaxKind.TypeOperator && typeAliasType.operator === SyntaxKind.KeyOfKeyword) {
-    const enumValues = getEnumValuesFromKeyOf(typeAliasType, ctx);
-    return { name, enumValues, comment, decorators: {}, sourceFile: ctx.sourceFile.fileName };
+    const enumValues = getEnumValuesFromKeyOf(typeAliasType, ctx2);
+    return { name, enumValues, comment, decorators: {}, sourceFile: ctx2.sourceFile.fileName };
   }
-  throw new Error(`Unexpected type definition - ${typeDeclaration.getText(ctx.sourceFile)}. Did you mean 'class'?`);
+  throw new Error(`Unexpected type definition - ${typeDeclaration.getText(ctx2.sourceFile)}. Did you mean 'class'?`);
 }
-function parseDecorators(modifiers, ctx) {
+function parseDecorators(modifiers, ctx2) {
   if (!modifiers)
     return {};
   const decoratorNodes = modifiers?.filter((x) => x.kind === SyntaxKind.Decorator) || [];
-  const decoratorsArray = decoratorNodes?.map((x) => parseDecorator(x, ctx)) || [];
+  const decoratorsArray = decoratorNodes?.map((x) => parseDecorator(x, ctx2)) || [];
   const decorators = {};
   for (const d of decoratorsArray) {
     decorators[d.name] = d.args;
   }
   return decorators;
 }
-function getEnumValues(node, parentNode, ctx) {
+function getEnumValues(node, parentNode, ctx2) {
   const enumValuesArray = node.types.map((node2) => {
     if (node2.kind !== SyntaxKind.LiteralType) {
-      throw new Error(`Unexpected type definition - ${parentNode.getText(ctx.sourceFile)}`);
+      throw new Error(`Unexpected type definition - ${parentNode.getText(ctx2.sourceFile)}`);
     }
     const { literal } = node2;
     if (literal.kind !== SyntaxKind.StringLiteral)
-      throw new Error(`Unexpected type definition - ${parentNode.getText(ctx.sourceFile)}`);
+      throw new Error(`Unexpected type definition - ${parentNode.getText(ctx2.sourceFile)}`);
     return { name: literal.text };
   });
   return _.keyBy(enumValuesArray, "name");
 }
-function parseClassMember(node, parentFields, parentName, ctx) {
-  const name = node.name.getText(ctx.sourceFile);
-  const { defaultValue, defaultValueCopyFrom, defaultValueClass } = parseDefaultValueExpression(node.initializer, ctx);
+function parseClassMember(node, parentFields, parentName, ctx2) {
+  const name = node.name.getText(ctx2.sourceFile);
+  const { defaultValue: defaultValue2, defaultValueCopyFrom, defaultValueClass } = parseDefaultValueExpression(node.initializer, ctx2);
   const isRequired = !node.questionToken;
   const comment = getCommentFromJsdocNode(node.jsDoc);
-  const decorators = parseDecorators(node.modifiers, ctx);
-  let defaultValueType = defaultValueClass || getPrimitiveTypeFromDefaultValue(defaultValue);
+  const decorators = parseDecorators(node.modifiers, ctx2);
+  let defaultValueType = defaultValueClass || getPrimitiveTypeFromDefaultValue(defaultValue2);
   if (defaultValueCopyFrom) {
     const parentField = parentFields[defaultValueCopyFrom];
     if (!parentField)
       throw new Error(`Cannot find field ${parentName}.${defaultValueCopyFrom}"`);
     defaultValueType = parentField.type;
   }
-  const parsedType = parseFieldType(ctx, parentName, name, node, defaultValueType);
+  const parsedType = parseFieldType(ctx2, parentName, name, node, defaultValueType);
   const result = {
     ...parsedType,
-    defaultValue,
+    defaultValue: defaultValue2,
     defaultValueCopyFrom,
     name,
     isRequired,
@@ -266,7 +266,7 @@ function getPrimitiveTypeFromDefaultValue(value) {
     return "object";
   return void 0;
 }
-function parseFieldType(ctx, parentName, fieldName, node, defaultValueType) {
+function parseFieldType(ctx2, parentName, fieldName, node, defaultValueType) {
   const parsedType = {
     isArray: false,
     isRelation: false,
@@ -277,21 +277,21 @@ function parseFieldType(ctx, parentName, fieldName, node, defaultValueType) {
     node
   };
   parseFieldTypeArray(parsedType, parentName);
-  parseFieldTypeRelation(parsedType, parentName, ctx);
-  parseFieldTypeInverseRelation(parsedType, parentName, ctx);
-  parseFieldTypeInlineEnum(parsedType, parentName, fieldName, ctx);
-  parseFieldTypeKeyofEnum(parsedType, parentName, fieldName, ctx);
-  parseFieldTypeRecordEnum(parsedType, parentName, fieldName, ctx);
-  parsedType.type = parsedType.type ?? parsedType.nodeType?.getText(ctx.sourceFile) ?? defaultValueType;
+  parseFieldTypeRelation(parsedType, parentName, ctx2);
+  parseFieldTypeInverseRelation(parsedType, parentName, ctx2);
+  parseFieldTypeInlineEnum(parsedType, parentName, fieldName, ctx2);
+  parseFieldTypeKeyofEnum(parsedType, parentName, fieldName, ctx2);
+  parseFieldTypeRecordEnum(parsedType, parentName, fieldName, ctx2);
+  parsedType.type = parsedType.type ?? parsedType.nodeType?.getText(ctx2.sourceFile) ?? defaultValueType;
   if (!parsedType.type)
-    throw new Error(`Cannot detect property type: '${node.getText(ctx.sourceFile)}'`);
+    throw new Error(`Cannot detect property type: '${node.getText(ctx2.sourceFile)}'`);
   if (parsedType.type.startsWith("Change<")) {
     parsedType.type = parsedType.type.slice(7, -1);
-    if (!ctx.typeNodesMap[parsedType.type])
+    if (!ctx2.typeNodesMap[parsedType.type])
       throw new Error(`Unexpected property type: '${parsedType.type}'`);
     parsedType.isChange = true;
   } else {
-    if (!supportedPrimitiveTypes.includes(parsedType.type) && !ctx.typeNodesMap[parsedType.type] && !ctx.result[parsedType.type]) {
+    if (!supportedPrimitiveTypes.includes(parsedType.type) && !ctx2.typeNodesMap[parsedType.type] && !ctx2.result[parsedType.type]) {
       throw new Error(`Unexpected property type: '${parsedType.type}'`);
     }
   }
@@ -305,31 +305,31 @@ function parseFieldType(ctx, parentName, fieldName, node, defaultValueType) {
     type: parsedType.type
   };
 }
-function parseFieldTypeRecordEnum(parsedType, parentName, fieldName, ctx) {
+function parseFieldTypeRecordEnum(parsedType, parentName, fieldName, ctx2) {
   if (parsedType.nodeType?.kind !== SyntaxKind.TypeReference)
     return;
   const nt = parsedType.nodeType;
-  if (nt.typeName.getText(ctx.sourceFile) !== "Record")
+  if (nt.typeName.getText(ctx2.sourceFile) !== "Record")
     return;
   if (nt.typeArguments?.length !== 2)
     return;
-  const keyTypeName = nt.typeArguments[0].getText(ctx.sourceFile);
-  const valueTypeName = nt.typeArguments[1].getText(ctx.sourceFile);
-  const keyType = ctx.typeNodesMap[keyTypeName];
+  const keyTypeName = nt.typeArguments[0].getText(ctx2.sourceFile);
+  const valueTypeName = nt.typeArguments[1].getText(ctx2.sourceFile);
+  const keyType = ctx2.typeNodesMap[keyTypeName];
   if (!keyType)
     return;
-  if (!ctx.result[keyTypeName])
-    ctx.result[keyTypeName] = parseClassOrTypeDeclaration(keyType.node, keyTypeName, ctx);
-  const enumValues = ctx.result[keyTypeName].enumValues;
+  if (!ctx2.result[keyTypeName])
+    ctx2.result[keyTypeName] = parseClassOrTypeDeclaration(keyType.node, keyTypeName, ctx2);
+  const enumValues = ctx2.result[keyTypeName].enumValues;
   if (!enumValues)
     throw new Error(`Unexpected type - ${keyTypeName}`);
   const newTypeName = `${parentName}_${_.upperFirst(fieldName)}`;
   const fieldsArray = _.values(enumValues).map((v) => ({ name: v.name, type: valueTypeName, isRequired: true }));
-  ctx.result[newTypeName] = {
+  ctx2.result[newTypeName] = {
     name: newTypeName,
     decorators: {},
     fields: _.keyBy(fieldsArray, "name"),
-    sourceFile: ctx.sourceFile.fileName
+    sourceFile: ctx2.sourceFile.fileName
   };
   parsedType.type = newTypeName;
 }
@@ -345,122 +345,122 @@ function parseFieldTypeArray(parsedType, parentName) {
     throw new Error(`Nested arrays are not supported (${parentName})`);
   }
 }
-function parseFieldTypeRelation(parsedType, parentName, ctx) {
+function parseFieldTypeRelation(parsedType, parentName, ctx2) {
   if (parsedType.nodeType?.kind !== SyntaxKind.TypeReference)
     return;
   const nt = parsedType.nodeType;
-  if (nt.typeName.getText(ctx.sourceFile) === "Relation") {
+  if (nt.typeName.getText(ctx2.sourceFile) === "Relation") {
     if (!nt.typeArguments?.length)
       throw new Error(`Missing type argument for Relation<>: '${parentName}'`);
     parsedType.nodeType = nt.typeArguments[0];
     parsedType.isRelation = true;
     if (nt.typeArguments[1]) {
       const ta = nt.typeArguments[1];
-      parsedType.relationDenormFields = getRelationDenormFields(ctx, ta);
+      parsedType.relationDenormFields = getRelationDenormFields(ctx2, ta);
     }
   }
 }
-function parseFieldTypeInverseRelation(parsedType, parentName, ctx) {
+function parseFieldTypeInverseRelation(parsedType, parentName, ctx2) {
   if (parsedType.nodeType?.kind !== SyntaxKind.TypeReference)
     return;
   const nt = parsedType.nodeType;
-  if (nt.typeName.getText(ctx.sourceFile) === "InverseRelation") {
+  if (nt.typeName.getText(ctx2.sourceFile) === "InverseRelation") {
     if (!nt.typeArguments?.length)
       throw new Error(`Missing type argument for Relation<>: '${parentName}'`);
-    parsedType.type = parseStringField(ctx, nt.typeArguments[0]);
+    parsedType.type = parseStringField(ctx2, nt.typeArguments[0]);
     parsedType.isInverseRelation = true;
     if (nt.typeArguments[1]) {
       const taNode = nt.typeArguments[1];
-      parsedType.inverseRelationField = parseStringField(ctx, taNode);
+      parsedType.inverseRelationField = parseStringField(ctx2, taNode);
     }
   }
 }
-function parseStringField(ctx, node) {
+function parseStringField(ctx2, node) {
   if (node.kind === SyntaxKind.LiteralType) {
     const literal = node.literal;
     if (literal.kind === SyntaxKind.StringLiteral) {
       return literal.text;
     }
   }
-  throw new Error(`Unexpected type - ${node.getText(ctx.sourceFile)}`);
+  throw new Error(`Unexpected type - ${node.getText(ctx2.sourceFile)}`);
 }
-function parseFieldTypeInlineEnum(parsedType, parentName, fieldName, ctx) {
+function parseFieldTypeInlineEnum(parsedType, parentName, fieldName, ctx2) {
   if (parsedType.nodeType?.kind !== SyntaxKind.UnionType)
     return;
   const nt = parsedType.nodeType;
-  const enumValues = getEnumValues(nt, parsedType.node, ctx);
+  const enumValues = getEnumValues(nt, parsedType.node, ctx2);
   const newTypeName = `${parentName}_${_.upperFirst(fieldName)}`;
-  ctx.result[newTypeName] = { name: newTypeName, decorators: {}, enumValues, sourceFile: ctx.sourceFile.fileName };
+  ctx2.result[newTypeName] = { name: newTypeName, decorators: {}, enumValues, sourceFile: ctx2.sourceFile.fileName };
   parsedType.type = newTypeName;
 }
-function parseFieldTypeKeyofEnum(parsedType, parentName, fieldName, ctx) {
+function parseFieldTypeKeyofEnum(parsedType, parentName, fieldName, ctx2) {
   if (parsedType.nodeType?.kind !== SyntaxKind.TypeOperator)
     return;
   const nt = parsedType.nodeType;
   if (nt.operator !== SyntaxKind.KeyOfKeyword)
     return;
-  const enumValues = getEnumValuesFromKeyOf(nt, ctx);
+  const enumValues = getEnumValuesFromKeyOf(nt, ctx2);
   const newTypeName = `${parentName}_${_.upperFirst(fieldName)}`;
-  ctx.result[newTypeName] = { name: newTypeName, decorators: {}, enumValues, sourceFile: ctx.sourceFile.fileName };
+  ctx2.result[newTypeName] = { name: newTypeName, decorators: {}, enumValues, sourceFile: ctx2.sourceFile.fileName };
   parsedType.type = newTypeName;
 }
-function getEnumValuesFromKeyOf(nodeType, ctx) {
+function getEnumValuesFromKeyOf(nodeType, ctx2) {
   if (nodeType.type.kind !== SyntaxKind.TypeReference) {
-    throw new Error(`Unexpected type - ${nodeType.type.getText(ctx.sourceFile)}`);
+    throw new Error(`Unexpected type - ${nodeType.type.getText(ctx2.sourceFile)}`);
   }
   const typeReferenceNode = nodeType.type;
   if (typeReferenceNode.typeName.kind !== SyntaxKind.Identifier) {
-    throw new Error(`Unexpected type - ${typeReferenceNode.getText(ctx.sourceFile)}`);
+    throw new Error(`Unexpected type - ${typeReferenceNode.getText(ctx2.sourceFile)}`);
   }
   const typeName = typeReferenceNode.typeName.text;
-  const type = ctx.typeNodesMap[typeName];
+  const type = ctx2.typeNodesMap[typeName];
   if (!type) {
     throw new Error(`Unexpected type - ${typeName}`);
   }
-  if (!ctx.result[typeName])
-    ctx.result[typeName] = parseClassOrTypeDeclaration(type.node, typeName, ctx);
-  if (!ctx.result[typeName].fields)
+  if (!ctx2.result[typeName])
+    ctx2.result[typeName] = parseClassOrTypeDeclaration(type.node, typeName, ctx2);
+  if (!ctx2.result[typeName].fields)
     throw new Error(`Unexpected type - ${typeName}`);
-  return _.mapValues(ctx.result[typeName].fields || {}, (v) => ({
+  return _.mapValues(ctx2.result[typeName].fields || {}, (v) => ({
     name: v.name,
     comment: v.comment,
     decorators: v.decorators
   }));
 }
-function getRelationDenormFields(ctx, node) {
+function getRelationDenormFields(ctx2, node) {
   if (node.kind === SyntaxKind.LiteralType) {
     const literal = node.literal;
     if (literal.kind === SyntaxKind.StringLiteral) {
       return [literal.text];
     }
-    throw new Error(`Unexpected type - ${literal.getText(ctx.sourceFile)}`);
+    throw new Error(`Unexpected type - ${literal.getText(ctx2.sourceFile)}`);
   }
   if (node.kind === SyntaxKind.UnionType) {
     const union = node;
-    return union.types.flatMap((t) => getRelationDenormFields(ctx, t));
+    return union.types.flatMap((t) => getRelationDenormFields(ctx2, t));
   }
-  throw new Error(`Unexpected type - ${node.getText(ctx.sourceFile)}`);
+  throw new Error(`Unexpected type - ${node.getText(ctx2.sourceFile)}`);
 }
-function verifyDefaultValueType(field, ctx) {
-  const { isArray, defaultValue, type } = field;
+function verifyDefaultValueType(field, ctx2) {
+  const { isArray, defaultValue: defaultValue2, type } = field;
   if (isArray) {
-    if (!_.isArray(defaultValue)) {
+    if (!_.isArray(defaultValue2)) {
       throw new TypeError(`Default value type is different from field type: '${type}'`);
     }
   } else {
-    if (supportedPrimitiveTypes.includes(type) && getPrimitiveTypeFromDefaultValue(defaultValue) !== type) {
+    if (supportedPrimitiveTypes.includes(type) && getPrimitiveTypeFromDefaultValue(defaultValue2) !== type) {
       throw new Error(`Default value type is different from field type: '${type}'`);
     }
-    if (!ctx.result[type] && ctx.typeNodesMap[type])
-      ctx.result[type] = parseClassOrTypeDeclaration(ctx.typeNodesMap[type].node, type, ctx);
-    const enumValues = ctx.result[type]?.enumValues;
-    if (enumValues && !enumValues[defaultValue]) {
+    if (!ctx2.result[type] && ctx2.typeNodesMap[type])
+      ctx2.result[type] = parseClassOrTypeDeclaration(ctx2.typeNodesMap[type].node, type, ctx2);
+    const enumValues = ctx2.result[type]?.enumValues;
+    if (enumValues && !enumValues[defaultValue2]) {
       const enumValuesStr = _.keys(enumValues).map((x) => `'x'`).join(", ");
       throw new Error(`Default value must be one of: ${enumValuesStr}`);
     }
   }
 }
-function verifyDefaultValueTypeCopyFrom(field, sourceField, ctx) {
+function verifyDefaultValueTypeCopyFrom(field, sourceField, ctx2) {
   const { isArray, type } = field;
   if (isArray) {
     if (!sourceField.isArray) {
@@ -472,37 +472,37 @@ function verifyDefaultValueTypeCopyFrom(field, sourceField, ctx) {
     }
   }
 }
-function parseDecorator(decoratorNode, ctx) {
-  const expr = decoratorNode.expression;
-  if (expr.kind !== SyntaxKind.CallExpression)
-    throw new Error(`Unexpected decorator format: "${expr.getText(ctx.sourceFile)}"`);
-  const nameNode = expr.expression;
+function parseDecorator(decoratorNode, ctx2) {
+  const expr2 = decoratorNode.expression;
+  if (expr2.kind !== SyntaxKind.CallExpression)
+    throw new Error(`Unexpected decorator format: "${expr2.getText(ctx2.sourceFile)}"`);
+  const nameNode = expr2.expression;
   if (nameNode.kind !== SyntaxKind.Identifier)
-    throw new Error(`Unexpected decorator format: "${nameNode.getText(ctx.sourceFile)}"`);
-  return { name: nameNode.text, args: parseDecoratorArguments(expr, ctx) };
+    throw new Error(`Unexpected decorator format: "${nameNode.getText(ctx2.sourceFile)}"`);
+  return { name: nameNode.text, args: parseDecoratorArguments(expr2, ctx2) };
 }
-function parseDecoratorArguments(expr, ctx) {
-  const args = expr.arguments;
+function parseDecoratorArguments(expr2, ctx2) {
+  const args = expr2.arguments;
   if (args.length === 0)
     return {};
   if (args.length > 1)
-    throw new Error(`Too many arguments - one expected: "${expr.getText(ctx.sourceFile)}"`);
+    throw new Error(`Too many arguments - one expected: "${expr2.getText(ctx2.sourceFile)}"`);
   const arg = args[0];
-  return parseLiteralNode(arg, ctx) ?? {};
+  return parseLiteralNode(arg, ctx2) ?? {};
 }
-function parseDefaultValueExpression(expr, ctx) {
-  if (!expr)
+function parseDefaultValueExpression(expr2, ctx2) {
+  if (!expr2)
     return {};
-  if (expr.kind === SyntaxKind.NewExpression) {
-    const identifier = expr.expression;
+  if (expr2.kind === SyntaxKind.NewExpression) {
+    const identifier = expr2.expression;
     const type = identifier?.text;
     if (type) {
       return { defaultValueClass: type, defaultValue: {} };
     }
-  } else if (expr.kind === SyntaxKind.PropertyAccessExpression && expr.expression.kind === SyntaxKind.ThisKeyword) {
-    return { defaultValueCopyFrom: expr.name?.text };
+  } else if (expr2.kind === SyntaxKind.PropertyAccessExpression && expr2.expression.kind === SyntaxKind.ThisKeyword) {
+    return { defaultValueCopyFrom: expr2.name?.text };
   }
-  return { defaultValue: parseLiteralNode(expr, ctx) };
+  return { defaultValue: parseLiteralNode(expr2, ctx2) };
 }
 function parseLiteralNode(expr, ctx) {
   if (!expr)
@@ -521,7 +521,7 @@ function parseLiteralNode(expr, ctx) {
     const defaultValueStr = expr.getText(ctx.sourceFile);
     let defaultValue;
     try {
-      defaultValue = JSON.parse(defaultValueStr.replace(/[\'\`]/gi, '"'));
+      defaultValue = eval(defaultValueStr);
     } catch (e) {
       throw new Error("Value must be valid array");
     }
@@ -531,18 +531,18 @@ function parseLiteralNode(expr, ctx) {
   }
   throw new Error(`Unexpected property expression: "${expr.getText(ctx.sourceFile)}"`);
 }
-function parseObjectLiteral(arg, ctx) {
+function parseObjectLiteral(arg, ctx2) {
   const result = {};
   for (const p of arg.properties) {
     if (!p.name || ![SyntaxKind.Identifier, SyntaxKind.StringLiteral].includes(p.name.kind))
-      throw new Error(`Unexpected property name: "${p.getText(ctx.sourceFile)}"`);
+      throw new Error(`Unexpected property name: "${p.getText(ctx2.sourceFile)}"`);
     const nameNode = p.name;
     const name = nameNode.text;
     if (p.kind !== SyntaxKind.PropertyAssignment)
-      throw new Error(`Unexpected property value: "${p.getText(ctx.sourceFile)}"`);
+      throw new Error(`Unexpected property value: "${p.getText(ctx2.sourceFile)}"`);
     const p2 = p;
     const valueExpression = p2.initializer;
-    const value = parseLiteralNode(valueExpression, ctx);
+    const value = parseLiteralNode(valueExpression, ctx2);
     result[name] = value;
   }
   return result;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rads-db",
-  "version": "3.0.78",
+  "version": "3.0.80",
   "packageManager": "pnpm@8.6.1",
   "description": "Say goodbye to boilerplate code and hello to efficient and elegant syntax.",
   "author": "",