rads-db 3.0.84 → 3.1.0

package/dist/config.cjs

@@ -0,0 +1,636 @@
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+const typescript = require('typescript');
+const _ = require('lodash');
+
+function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e.default : e; }
+
+const fs__default = /*#__PURE__*/_interopDefaultCompat(fs);
+const path__default = /*#__PURE__*/_interopDefaultCompat(path);
+const ___default = /*#__PURE__*/_interopDefaultCompat(_);
+
+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 = 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 = ___default.values(fields).filter((f) => !!f.decorators?.precomputed).sort((f1, f2) => getOrder(f1) - getOrder(f2)).map((f) => f.name);
+    const computedFields = ___default.values(fields).filter((f) => !!f.decorators?.computed).sort((f1, f2) => getOrder(f1) - getOrder(f2)).map((f) => f.name);
+    const nestedTypeFields = ___default.values(fields).filter((f) => result[f.type] && result[f.type].fields && !result[f.type].decorators.entity).map((f) => f.name);
+    const keepHistoryFields = ___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 = ___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 ___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 (!___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 (___default.isString(value))
+    return "string";
+  if (___default.isNumber(value))
+    return "number";
+  if (___default.isBoolean(value))
+    return "boolean";
+  if (___default.isArray(value))
+    return "array";
+  if (___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}_${___default.upperFirst(fieldName)}`;
+  const fieldsArray = ___default.values(enumValues).map((v) => ({ name: v.name, type: valueTypeName, isRequired: true }));
+  ctx2.result[newTypeName] = {
+    name: newTypeName,
+    decorators: {},
+    fields: ___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}_${___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}_${___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 ___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 (!___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 = ___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 (!___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.`
+          );
+      }
+    }
+  }
+}
+
+function defineRadsConfig(config) {
+  return config;
+}
+function schemaFromFiles(entitiesDir) {
+  return async () => {
+    if (!fs__default.existsSync(entitiesDir))
+      await fs__default.promises.mkdir(entitiesDir, { recursive: true });
+    const response = await fs__default.promises.readdir(entitiesDir, { withFileTypes: true });
+    const entities = {};
+    for (const file of response) {
+      if (!file.isFile())
+        continue;
+      if (!file.name.endsWith(".ts"))
+        continue;
+      const text = await fs__default.promises.readFile(path__default.resolve(entitiesDir, file.name), "utf-8");
+      entities[file.name.slice(0, -3)] = text;
+    }
+    return { schema: parseSchema(entities), entitiesDir };
+  };
+}
+function schemaFromRadsApi(radsApiUrl) {
+  return async () => {
+    const url = new URL("radsTunnel", radsApiUrl);
+    const fetchResponse = await fetch(url.href, {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({ method: "_schema" })
+    });
+    console.log("loading", url.href);
+    const schema = await fetchResponse.json();
+    if (!schema) {
+      throw new Error("Could not download schema from the server. Please check the server URL.");
+    }
+    return { schema };
+  };
+}
+
+exports.defineRadsConfig = defineRadsConfig;
+exports.schemaFromFiles = schemaFromFiles;
+exports.schemaFromRadsApi = schemaFromRadsApi;

package/dist/config.d.ts

@@ -0,0 +1,23 @@
+import { g as RadsConfig, T as TypeDefinition } from './types-7e792d1f.js';
+import '_rads-db';
+
+declare function defineRadsConfig(config: RadsConfig): RadsConfig;
+/**
+ * Loads all typescript files in given folder, parses them and outputs schema.
+ * @param entitiesDir - path from project root to folder with typescript files, e.g. './entities'
+ * @returns schema object
+ */
+declare function schemaFromFiles(entitiesDir: string): () => Promise<{
+    schema: Record<string, TypeDefinition>;
+    entitiesDir: string;
+}>;
+/**
+ * Loads schema from the rads api.
+ * @param radsApiUrl - URL where to download schema fiels, e.g. 'https://radsjs.com/api/'
+ * @returns schema object
+ */
+declare function schemaFromRadsApi(radsApiUrl: string): () => Promise<{
+    schema: any;
+}>;
+
+export { defineRadsConfig, schemaFromFiles, schemaFromRadsApi };