rads-db 3.0.84 → 3.1.0

package/integrations/lib.cjs

@@ -1,603 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.parseSchema = parseSchema;
-var _typescript = require("typescript");
-var _lodash = _interopRequireDefault(require("lodash"));
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-const supportedPrimitiveTypes = ["string", "number", "boolean", "Record<string, string>", "Record<string, any>"];
-function parseSchema(typescriptFiles) {
-  const typeNodesMap = getTypeNodesMap(typescriptFiles);
-  const schema = getSchema(typeNodesMap);
-  resolveIsExtending(schema);
-  fillComputedDefinitionsForType(schema);
-  verifyDefaultValueTypes(schema, typeNodesMap);
-  verifyRelationFields(schema);
-  return schema;
-}
-function resolveIsExtending(schema) {
-  for (const key in schema) {
-    const isExtendingType = schema[key].isExtending;
-    if (!isExtendingType) continue;
-    if (!schema[isExtendingType]) throw new Error(`Unknown type: "${isExtendingType}"`);
-    schema[key].fields = {
-      ...schema[isExtendingType].fields,
-      ...schema[key].fields
-    };
-    schema[key].decorators = {
-      ...schema[isExtendingType].decorators,
-      ...schema[key].decorators
-    };
-    if (schema[key].decorators.entity && !schema[key].fields?.id) {
-      throw new Error(`Entity "${key}" must have an id`);
-    }
-  }
-}
-function getSchema(typeNodesMap) {
-  const result = {};
-  for (const key in typeNodesMap) {
-    const {
-      node,
-      name
-    } = typeNodesMap[key];
-    if (![_typescript.SyntaxKind.ClassDeclaration, _typescript.SyntaxKind.TypeAliasDeclaration].includes(node.kind)) {
-      throw new Error(`Unexpected type kind - "${name}"`);
-    }
-  }
-  for (const key in typeNodesMap) {
-    if (result[key]) continue;
-    const {
-      node,
-      sourceFile,
-      name
-    } = typeNodesMap[key];
-    if (node.kind !== _typescript.SyntaxKind.ClassDeclaration) continue;
-    const parsedClass = parseClassDeclaration(node, name, {
-      typeNodesMap,
-      sourceFile,
-      result
-    });
-    result[key] = parsedClass;
-  }
-  for (const key in typeNodesMap) {
-    if (result[key]) continue;
-    const {
-      node,
-      sourceFile,
-      name
-    } = typeNodesMap[key];
-    if (node.kind !== _typescript.SyntaxKind.TypeAliasDeclaration) continue;
-    const parsedClass = parseTypeAliasDeclaration(node, name, {
-      typeNodesMap,
-      sourceFile,
-      result
-    });
-    result[key] = parsedClass;
-  }
-  return result;
-}
-function getTypeNodesMap(typescriptFiles) {
-  const typeNodesMap = {};
-  for (const key in typescriptFiles) {
-    const text = typescriptFiles[key];
-    const sourceFile = (0, _typescript.createSourceFile)(`${key}.ts`, text, _typescript.ScriptTarget.Latest);
-    const classDeclarations = getClassDeclarations(sourceFile);
-    for (const cd of classDeclarations) {
-      const nameNode = cd.name;
-      if (!nameNode || nameNode.kind !== _typescript.SyntaxKind.Identifier) throw new Error("Cannot detect class name");
-      const name = nameNode.text;
-      typeNodesMap[name] = {
-        name,
-        node: cd,
-        sourceFile
-      };
-    }
-    if (!typeNodesMap[key]) {
-      throw new Error(`File ${key}.ts must contain class declaration with name "${key}"`);
-    }
-  }
-  return typeNodesMap;
-}
-function verifyDefaultValueTypes(schema, typeNodesMap) {
-  for (const key in schema) {
-    const type = schema[key];
-    const fields = type.fields;
-    if (!fields) continue;
-    for (const fName in fields) {
-      const field = fields[fName];
-      if (field.defaultValue) {
-        verifyDefaultValueType(field, {
-          typeNodesMap,
-          result: schema,
-          sourceFile: typeNodesMap[key]?.sourceFile
-        });
-      }
-      for (const fName2 in fields) {
-        const field2 = fields[fName2];
-        if (field2.defaultValueCopyFrom) {
-          const sourceField = fields[field2.defaultValueCopyFrom];
-          if (!sourceField) throw new Error(`Cannot find field ${key}.${field2.defaultValueCopyFrom}"`);
-          verifyDefaultValueTypeCopyFrom(field2, sourceField, {
-            typeNodesMap,
-            result: schema,
-            sourceFile: typeNodesMap[key]?.sourceFile
-          });
-        }
-      }
-    }
-  }
-}
-function fillComputedDefinitionsForType(result) {
-  for (const key in result) {
-    const type = result[key];
-    const fields = type.fields;
-    if (!fields) continue;
-    const precomputedFields = _lodash.default.values(fields).filter(f => !!f.decorators?.precomputed).sort((f1, f2) => getOrder(f1) - getOrder(f2)).map(f => f.name);
-    const computedFields = _lodash.default.values(fields).filter(f => !!f.decorators?.computed).sort((f1, f2) => getOrder(f1) - getOrder(f2)).map(f => f.name);
-    const nestedTypeFields = _lodash.default.values(fields).filter(f => result[f.type] && result[f.type].fields && !result[f.type].decorators.entity).map(f => f.name);
-    const keepHistoryFields = _lodash.default.values(fields).filter(f => !!f.decorators?.keepHistory).map(f => f.name);
-    if (precomputedFields.length) type.precomputedFields = precomputedFields;
-    if (computedFields.length) type.computedFields = computedFields;
-    if (nestedTypeFields.length) type.nestedTypeFields = nestedTypeFields;
-    if (keepHistoryFields.length) type.keepHistoryFields = keepHistoryFields;
-  }
-}
-function getOrder(f) {
-  const decorator = f.decorators.computed || f.decorators.precomputed;
-  const defaultOrders = {
-    createdAt: -1e5,
-    updatedAt: -9e4
-  };
-  return decorator.order ?? defaultOrders[decorator.preset] ?? 0;
-}
-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, ctx2) {
-  if (ctx2.result[typeName]) return ctx2.result[typeName];
-  const {
-    modifiers
-  } = typeDeclaration;
-  const nameNode = typeDeclaration.name;
-  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, 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 !== _typescript.SyntaxKind.PropertyDeclaration) {
-      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, ctx2);
-    fields[field.name] = field;
-  }
-  const handle = _lodash.default.lowerFirst(name);
-  const handlePlural = `${handle}/list`;
-  const result = {
-    name,
-    handle,
-    handlePlural,
-    decorators,
-    fields,
-    isExtending,
-    comment,
-    sourceFile: ctx2.sourceFile.fileName
-  };
-  return result;
-}
-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;
-  const comment = getCommentFromJsdocNode(typeDeclaration.jsDoc);
-  const typeAliasDeclaration = typeDeclaration;
-  const typeAliasType = typeAliasDeclaration.type;
-  if (typeAliasType.kind === _typescript.SyntaxKind.UnionType) {
-    const typeAliasValue = typeAliasDeclaration.type;
-    const enumValues = getEnumValues(typeAliasValue, typeDeclaration, ctx2);
-    return {
-      name,
-      enumValues,
-      comment,
-      decorators: {},
-      sourceFile: ctx2.sourceFile.fileName
-    };
-  }
-  if (typeAliasType.kind === _typescript.SyntaxKind.TypeOperator && typeAliasType.operator === _typescript.SyntaxKind.KeyOfKeyword) {
-    const enumValues = getEnumValuesFromKeyOf(typeAliasType, ctx2);
-    return {
-      name,
-      enumValues,
-      comment,
-      decorators: {},
-      sourceFile: ctx2.sourceFile.fileName
-    };
-  }
-  throw new Error(`Unexpected type definition - ${typeDeclaration.getText(ctx2.sourceFile)}. Did you mean 'class'?`);
-}
-function parseDecorators(modifiers, ctx2) {
-  if (!modifiers) return {};
-  const decoratorNodes = modifiers?.filter(x => x.kind === _typescript.SyntaxKind.Decorator) || [];
-  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, ctx2) {
-  const enumValuesArray = node.types.map(node2 => {
-    if (node2.kind !== _typescript.SyntaxKind.LiteralType) {
-      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(ctx2.sourceFile)}`);
-    return {
-      name: literal.text
-    };
-  });
-  return _lodash.default.keyBy(enumValuesArray, "name");
-}
-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, 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(ctx2, parentName, name, node, defaultValueType);
-  const result = {
-    ...parsedType,
-    defaultValue: defaultValue2,
-    defaultValueCopyFrom,
-    name,
-    isRequired,
-    comment
-  };
-  if (!_lodash.default.isEmpty(decorators)) result.decorators = decorators;
-  if (defaultValueClass) result.defaultValueClass = defaultValueClass;
-  return result;
-}
-function getCommentFromJsdocNode(jsDoc) {
-  const comment = jsDoc?.[0]?.comment;
-  const tags = jsDoc?.[0]?.tags;
-  const tagsStr = tags?.map(tag => [`@${tag.tagName.text}`, tag.comment || ""].filter(x => x).join(" "))?.join("\n") || "";
-  return [comment, tagsStr].filter(x => x).join("\n") || void 0;
-}
-function getPrimitiveTypeFromDefaultValue(value) {
-  if (_lodash.default.isString(value)) return "string";
-  if (_lodash.default.isNumber(value)) return "number";
-  if (_lodash.default.isBoolean(value)) return "boolean";
-  if (_lodash.default.isArray(value)) return "array";
-  if (_lodash.default.isObject(value)) return "object";
-  return void 0;
-}
-function parseFieldType(ctx2, parentName, fieldName, node, defaultValueType) {
-  const parsedType = {
-    isArray: false,
-    isRelation: false,
-    isChange: false,
-    relationDenormFields: void 0,
-    type: void 0,
-    nodeType: node.type,
-    node
-  };
-  parseFieldTypeArray(parsedType, parentName);
-  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 (!ctx2.typeNodesMap[parsedType.type]) throw new Error(`Unexpected property type: '${parsedType.type}'`);
-    parsedType.isChange = true;
-  } else {
-    if (!supportedPrimitiveTypes.includes(parsedType.type) && !ctx2.typeNodesMap[parsedType.type] && !ctx2.result[parsedType.type]) {
-      throw new Error(`Unexpected property type: '${parsedType.type}'`);
-    }
-  }
-  return {
-    isArray: parsedType.isArray || void 0,
-    isRelation: parsedType.isRelation || void 0,
-    isInverseRelation: parsedType.isInverseRelation || void 0,
-    isChange: parsedType.isChange || void 0,
-    relationDenormFields: parsedType.relationDenormFields,
-    inverseRelationField: parsedType.inverseRelationField,
-    type: parsedType.type
-  };
-}
-function parseFieldTypeRecordEnum(parsedType, parentName, fieldName, ctx2) {
-  if (parsedType.nodeType?.kind !== _typescript.SyntaxKind.TypeReference) return;
-  const nt = parsedType.nodeType;
-  if (nt.typeName.getText(ctx2.sourceFile) !== "Record") return;
-  if (nt.typeArguments?.length !== 2) return;
-  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 (!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 => ({
-    name: v.name,
-    type: valueTypeName,
-    isRequired: true
-  }));
-  ctx2.result[newTypeName] = {
-    name: newTypeName,
-    decorators: {},
-    fields: _lodash.default.keyBy(fieldsArray, "name"),
-    sourceFile: ctx2.sourceFile.fileName
-  };
-  parsedType.type = newTypeName;
-}
-function parseFieldTypeArray(parsedType, parentName) {
-  if (parsedType.nodeType?.kind !== _typescript.SyntaxKind.ArrayType) return;
-  parsedType.isArray = true;
-  parsedType.nodeType = parsedType.nodeType.elementType;
-  if (parsedType.nodeType?.kind === _typescript.SyntaxKind.ParenthesizedType) {
-    parsedType.nodeType = parsedType.nodeType.type;
-  }
-  if (parsedType.nodeType?.kind === _typescript.SyntaxKind.ArrayType) {
-    throw new Error(`Nested arrays are not supported (${parentName})`);
-  }
-}
-function parseFieldTypeRelation(parsedType, parentName, ctx2) {
-  if (parsedType.nodeType?.kind !== _typescript.SyntaxKind.TypeReference) return;
-  const nt = parsedType.nodeType;
-  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(ctx2, ta);
-    }
-  }
-}
-function parseFieldTypeInverseRelation(parsedType, parentName, ctx2) {
-  if (parsedType.nodeType?.kind !== _typescript.SyntaxKind.TypeReference) return;
-  const nt = parsedType.nodeType;
-  if (nt.typeName.getText(ctx2.sourceFile) === "InverseRelation") {
-    if (!nt.typeArguments?.length) throw new Error(`Missing type argument for Relation<>: '${parentName}'`);
-    parsedType.type = parseStringField(ctx2, nt.typeArguments[0]);
-    parsedType.isInverseRelation = true;
-    if (nt.typeArguments[1]) {
-      const taNode = nt.typeArguments[1];
-      parsedType.inverseRelationField = parseStringField(ctx2, taNode);
-    }
-  }
-}
-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(ctx2.sourceFile)}`);
-}
-function parseFieldTypeInlineEnum(parsedType, parentName, fieldName, ctx2) {
-  if (parsedType.nodeType?.kind !== _typescript.SyntaxKind.UnionType) return;
-  const nt = parsedType.nodeType;
-  const enumValues = getEnumValues(nt, parsedType.node, ctx2);
-  const newTypeName = `${parentName}_${_lodash.default.upperFirst(fieldName)}`;
-  ctx2.result[newTypeName] = {
-    name: newTypeName,
-    decorators: {},
-    enumValues,
-    sourceFile: ctx2.sourceFile.fileName
-  };
-  parsedType.type = newTypeName;
-}
-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, ctx2);
-  const newTypeName = `${parentName}_${_lodash.default.upperFirst(fieldName)}`;
-  ctx2.result[newTypeName] = {
-    name: newTypeName,
-    decorators: {},
-    enumValues,
-    sourceFile: ctx2.sourceFile.fileName
-  };
-  parsedType.type = newTypeName;
-}
-function getEnumValuesFromKeyOf(nodeType, ctx2) {
-  if (nodeType.type.kind !== _typescript.SyntaxKind.TypeReference) {
-    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(ctx2.sourceFile)}`);
-  }
-  const typeName = typeReferenceNode.typeName.text;
-  const type = ctx2.typeNodesMap[typeName];
-  if (!type) {
-    throw new Error(`Unexpected type - ${typeName}`);
-  }
-  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(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(ctx2.sourceFile)}`);
-  }
-  if (node.kind === _typescript.SyntaxKind.UnionType) {
-    const union = node;
-    return union.types.flatMap(t => getRelationDenormFields(ctx2, t));
-  }
-  throw new Error(`Unexpected type - ${node.getText(ctx2.sourceFile)}`);
-}
-function verifyDefaultValueType(field, ctx2) {
-  const {
-    isArray,
-    defaultValue: defaultValue2,
-    type
-  } = field;
-  if (isArray) {
-    if (!_lodash.default.isArray(defaultValue2)) {
-      throw new TypeError(`Default value type is different from field type: '${type}'`);
-    }
-  } else {
-    if (supportedPrimitiveTypes.includes(type) && getPrimitiveTypeFromDefaultValue(defaultValue2) !== type) {
-      throw new Error(`Default value type is different from field type: '${type}'`);
-    }
-    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, ctx2) {
-  const {
-    isArray,
-    type
-  } = field;
-  if (isArray) {
-    if (!sourceField.isArray) {
-      throw new TypeError(`Default value type is not an array: '${field.name}'`);
-    }
-  } else {
-    if (sourceField.type !== type) {
-      throw new Error(`Default value type is different from field type: '${field.name}'`);
-    }
-  }
-}
-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(expr2, ctx2)
-  };
-}
-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: "${expr2.getText(ctx2.sourceFile)}"`);
-  const arg = args[0];
-  return parseLiteralNode(arg, ctx2) ?? {};
-}
-function parseDefaultValueExpression(expr2, ctx2) {
-  if (!expr2) return {};
-  if (expr2.kind === _typescript.SyntaxKind.NewExpression) {
-    const identifier = expr2.expression;
-    const type = identifier?.text;
-    if (type) {
-      return {
-        defaultValueClass: type,
-        defaultValue: {}
-      };
-    }
-  } else if (expr2.kind === _typescript.SyntaxKind.PropertyAccessExpression && expr2.expression.kind === _typescript.SyntaxKind.ThisKeyword) {
-    return {
-      defaultValueCopyFrom: expr2.name?.text
-    };
-  }
-  return {
-    defaultValue: parseLiteralNode(expr2, ctx2)
-  };
-}
-function parseLiteralNode(expr, ctx) {
-  if (!expr) return void 0;
-  if (expr.kind === _typescript.SyntaxKind.StringLiteral) return expr.text;
-  if (expr.kind === _typescript.SyntaxKind.FalseKeyword) return false;
-  if (expr.kind === _typescript.SyntaxKind.TrueKeyword) return true;
-  if (expr.kind === _typescript.SyntaxKind.NumericLiteral) return Number.parseFloat(expr.text);
-  if (expr.kind === _typescript.SyntaxKind.ObjectLiteralExpression) return parseObjectLiteral(expr, ctx);
-  if (expr.kind === _typescript.SyntaxKind.ArrayLiteralExpression) {
-    const defaultValueStr = expr.getText(ctx.sourceFile);
-    let defaultValue;
-    try {
-      defaultValue = eval(defaultValueStr);
-    } catch (e) {
-      throw new Error("Value must be valid array");
-    }
-    if (!_lodash.default.isArray(defaultValue)) throw new Error("Value must be valid array");
-    return defaultValue;
-  }
-  throw new Error(`Unexpected property expression: "${expr.getText(ctx.sourceFile)}"`);
-}
-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(ctx2.sourceFile)}"`);
-    const nameNode = p.name;
-    const name = nameNode.text;
-    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, ctx2);
-    result[name] = value;
-  }
-  return result;
-}
-function getClassDeclarations(sourceFile) {
-  const children = sourceFile.getChildren();
-  const syntaxListNode = children.find(c => c.kind === _typescript.SyntaxKind.SyntaxList);
-  const result = syntaxListNode?.getChildren().filter(c => [_typescript.SyntaxKind.ClassDeclaration, _typescript.SyntaxKind.TypeAliasDeclaration].includes(c.kind));
-  return result || [];
-}
-function verifyRelationFields(result) {
-  for (const key in result) {
-    const type = result[key];
-    for (const fieldName in type.fields) {
-      const field = type.fields[fieldName];
-      if (field.isRelation && !result[field.type]?.decorators?.entity) {
-        throw new Error(`${key}.${fieldName}: Relation must point to an entity. Got "${field.type}" instead.`);
-      }
-      if (field.isInverseRelation) {
-        if (!result[field.type]?.decorators?.entity) throw new Error(`${key}.${fieldName}: InverseRelation must point to an entity. Got "${field.type}" instead.`);
-        if (field.isRequired) throw new Error(`${key}.${fieldName}: InverseRelation cannot be required. Please, add "?" to the field name.`);
-        if (!field.isArray) throw new Error(`${key}.${fieldName}: InverseRelation must be an array.`);
-        if (!field.inverseRelationField) throw new Error(`${key}.${fieldName}: InverseRelation must have a field name.`);
-        if (!result[field.type]?.fields?.[field.inverseRelationField]?.isRelation) throw new Error(`${key}.${fieldName}: InverseRelation field must point to relation field. Got "${field.inverseRelationField}" instead.`);
-        if (result[field.type]?.fields?.[field.inverseRelationField]?.type !== key) throw new Error(`${key}.${fieldName}: InverseRelation field must point to the current entity. Got "${field.inverseRelationField}" instead.`);
-      }
-    }
-  }
-}

package/integrations/lib.d.ts

@@ -1 +0,0 @@
-export declare function parseSchema(typescriptFiles: Record<string, string>): Record<string, TypeDefinition>;