rads-db 3.0.18 → 3.0.20

package/dist/index.d.ts

@@ -206,6 +206,7 @@ interface TypeDefinition {
     enumValues?: Record<string, EnumDefinition>;
     handle?: string;
     handlePlural?: string;
+    isExtending?: string;
 }
 interface FileUploadResult {
     url: string;
@@ -256,6 +257,7 @@ interface FieldDefinition {
     name: string;
     type: string;
     defaultValue?: any;
+    defaultValueClass?: string;
     defaultValueCopyFrom?: string;
     isRequired?: boolean;
     isArray?: boolean;

package/integrations/lib.cjs

@@ -10,8 +10,77 @@ var _pluralize = _interopRequireDefault(require("pluralize"));
 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 = {};
-  const typesMap = {};
+  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);
@@ -20,75 +89,44 @@ function parseSchema(typescriptFiles) {
       const nameNode = cd.name;
       if (!nameNode || nameNode.kind !== _typescript.SyntaxKind.Identifier) throw new Error("Cannot detect class name");
       const name = nameNode.text;
-      typesMap[name] = {
+      typeNodesMap[name] = {
         name,
         node: cd,
         sourceFile
       };
     }
-    if (!typesMap[key]) {
+    if (!typeNodesMap[key]) {
       throw new Error(`File ${key}.ts must contain class declaration with name "${key}"`);
     }
   }
-  for (const key in typesMap) {
-    if (result[key]) continue;
-    const {
-      node,
-      sourceFile,
-      name
-    } = typesMap[key];
-    const parsedClass = parseType(node, name, {
-      typesMap,
-      sourceFile,
-      result
-    });
-    if (parsedClass.name !== key) throw new Error(`File name must correspond to exported class name ("${key}", "${parsedClass.name}")`);
-    result[key] = parsedClass;
-  }
-  for (const key in result) {
-    const isExtendingType = result[key].isExtending;
-    if (!isExtendingType) continue;
-    if (!result[isExtendingType]) throw new Error(`Unknown type: "${isExtendingType}"`);
-    result[key].fields = {
-      ...result[isExtendingType].fields,
-      ...result[key].fields
-    };
-    result[key].decorators = {
-      ...result[isExtendingType].decorators,
-      ...result[key].decorators
-    };
-    if (result[key].decorators.entity && !result[key].fields?.id) {
-      throw new Error(`Entity "${key}" must have an id`);
-    }
-  }
-  fillComputedDefinitionsForType(result);
-  processThisReferenceDefaultValues(result, typesMap);
-  verifyRelationFields(result);
-  return result;
+  return typeNodesMap;
 }
-function processThisReferenceDefaultValues(result, typesMap) {
-  for (const key in result) {
-    const type = result[key];
+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.defaultValueCopyFrom) {
-        const sourceField = fields[field.defaultValueCopyFrom];
-        if (!sourceField) throw new Error(`Cannot find field ${key}.${field.defaultValueCopyFrom}"`);
-        if (field.type === "thisReference") {
-          field.type = sourceField.type;
-          field.isArray = sourceField.isArray;
-        }
-        verifyDefaultValueType(field.isArray || false, {
-          type: sourceField.type,
-          value: sourceField.defaultValue
-        }, field.type, supportedPrimitiveTypes, {
-          typesMap,
-          result,
-          sourceFile: typesMap[key]?.sourceFile
+      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
+          });
+        }
+      }
     }
   }
 }
@@ -113,7 +151,12 @@ function getOrder(f) {
   };
   return decorator.order ?? defaultOrders[decorator.preset] ?? 0;
 }
-function parseType(typeDeclaration, typeName, ctx) {
+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);
+  throw new Error(`Unexpected type definition - ${typeName}`);
+}
+function parseClassDeclaration(typeDeclaration, typeName, ctx) {
   if (ctx.result[typeName]) return ctx.result[typeName];
   const {
     modifiers
@@ -123,62 +166,64 @@ function parseType(typeDeclaration, typeName, ctx) {
   const name = nameNode.text;
   const comment = typeDeclaration.jsDoc?.[0]?.comment;
   const decorators = parseDecorators(modifiers, ctx);
-  if (typeDeclaration.kind === _typescript.SyntaxKind.ClassDeclaration) {
-    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(ctx.sourceFile)}")`);
-      }
-    }
-    const fieldsArray = members.map(m => parseClassMember(m, name, ctx));
-    const fields = {};
-    for (const f of fieldsArray) {
-      fields[f.name] = f;
+  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(ctx.sourceFile)}")`);
     }
-    const handle = _lodash.default.lowerFirst(name);
-    const handlePlural = (0, _pluralize.default)(handle);
-    const result = {
+  }
+  const fields = {};
+  for (const m of members) {
+    const field = parseClassMember(m, fields, name, ctx);
+    fields[field.name] = field;
+  }
+  const handle = _lodash.default.lowerFirst(name);
+  const handlePlural = (0, _pluralize.default)(handle);
+  const result = {
+    name,
+    handle,
+    handlePlural,
+    decorators,
+    fields,
+    isExtending,
+    comment
+  };
+  return result;
+}
+function parseTypeAliasDeclaration(typeDeclaration, typeName, ctx) {
+  if (ctx.result[typeName]) return ctx.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 = typeDeclaration.jsDoc?.[0]?.comment;
+  const typeAliasDeclaration = typeDeclaration;
+  const typeAliasType = typeAliasDeclaration.type;
+  if (typeAliasType.kind === _typescript.SyntaxKind.UnionType) {
+    const typeAliasValue = typeAliasDeclaration.type;
+    const enumValues = getEnumValues(typeAliasValue, typeDeclaration, ctx);
+    return {
       name,
-      handle,
-      handlePlural,
-      decorators,
-      fields,
-      isExtending,
-      comment
+      enumValues,
+      comment,
+      decorators: {}
     };
-    return result;
   }
-  if (typeDeclaration.kind === _typescript.SyntaxKind.TypeAliasDeclaration) {
-    const typeAliasDeclaration = typeDeclaration;
-    const typeAliasType = typeAliasDeclaration.type;
-    if (typeAliasType.kind === _typescript.SyntaxKind.UnionType) {
-      const typeAliasValue = typeAliasDeclaration.type;
-      const enumValues = getEnumValues(typeAliasValue, typeDeclaration, ctx);
-      return {
-        name,
-        decorators,
-        enumValues,
-        comment
-      };
-    }
-    if (typeAliasType.kind === _typescript.SyntaxKind.TypeOperator && typeAliasType.operator === _typescript.SyntaxKind.KeyOfKeyword) {
-      const enumValues = getEnumValuesFromKeyOf(typeAliasType, ctx);
-      return {
-        name,
-        decorators,
-        enumValues,
-        comment
-      };
-    }
-    throw new Error(`Unexpected type definition - ${typeDeclaration.getText(ctx.sourceFile)}. Did you mean 'class'?`);
+  if (typeAliasType.kind === _typescript.SyntaxKind.TypeOperator && typeAliasType.operator === _typescript.SyntaxKind.KeyOfKeyword) {
+    const enumValues = getEnumValuesFromKeyOf(typeAliasType, ctx);
+    return {
+      name,
+      enumValues,
+      comment,
+      decorators: {}
+    };
   }
-  throw new Error(`Unexpected type kind - "${name}"`);
+  throw new Error(`Unexpected type definition - ${typeDeclaration.getText(ctx.sourceFile)}. Did you mean 'class'?`);
 }
 function parseDecorators(modifiers, ctx) {
   if (!modifiers) return {};
@@ -205,28 +250,29 @@ function getEnumValues(node, parentNode, ctx) {
   });
   return _lodash.default.keyBy(enumValuesArray, "name");
 }
-function parseClassMember(node, parentName, ctx) {
+function parseClassMember(node, parentFields, parentName, ctx) {
   const name = node.name.getText(ctx.sourceFile);
-  const defaultValueDescription = parseLiteralNode(node.initializer, ctx);
-  let defaultValue;
-  let defaultValueCopyFrom;
-  if (defaultValueDescription) {
-    if (defaultValueDescription.type === "thisReference") {
-      defaultValueCopyFrom = defaultValueDescription.value;
-    } else {
-      defaultValue = defaultValueDescription.value;
-    }
-  }
+  const {
+    defaultValue,
+    defaultValueCopyFrom,
+    defaultValueClass
+  } = parseDefaultValueExpression(node.initializer, ctx);
   const isRequired = !node.questionToken;
   const comment = node.jsDoc?.[0]?.comment;
   const decorators = parseDecorators(node.modifiers, ctx);
+  let defaultValueType = defaultValueClass || getPrimitiveTypeFromDefaultValue(defaultValue);
+  if (defaultValueCopyFrom) {
+    const parentField = parentFields[defaultValueCopyFrom];
+    if (!parentField) throw new Error(`Cannot find field ${parentName}.${defaultValueCopyFrom}"`);
+    defaultValueType = parentField.type;
+  }
   const {
     isArray,
     isRelation,
     isChange,
     relationDenormFields,
     type
-  } = parseFieldType(ctx, parentName, name, node, defaultValueDescription);
+  } = parseFieldType(ctx, parentName, name, node, defaultValueType);
   const result = {
     type,
     defaultValue,
@@ -240,9 +286,18 @@ function parseClassMember(node, parentName, ctx) {
     comment
   };
   if (!_lodash.default.isEmpty(decorators)) result.decorators = decorators;
+  if (defaultValueClass) result.defaultValueClass = defaultValueClass;
   return result;
 }
-function parseFieldType(ctx, parentName, fieldName, node, defaultValueDescription) {
+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(ctx, parentName, fieldName, node, defaultValueType) {
   const parsedType = {
     isArray: false,
     isRelation: false,
@@ -257,20 +312,17 @@ function parseFieldType(ctx, parentName, fieldName, node, defaultValueDescriptio
   parseFieldTypeInlineEnum(parsedType, parentName, fieldName, ctx);
   parseFieldTypeKeyofEnum(parsedType, parentName, fieldName, ctx);
   parseFieldTypeRecordEnum(parsedType, parentName, fieldName, ctx);
-  parsedType.type = parsedType.type ?? parsedType.nodeType?.getText(ctx.sourceFile) ?? defaultValueDescription?.type;
+  parsedType.type = parsedType.type ?? parsedType.nodeType?.getText(ctx.sourceFile) ?? defaultValueType;
   if (!parsedType.type) throw new Error(`Cannot detect property type: '${node.getText(ctx.sourceFile)}'`);
   if (parsedType.type.startsWith("Change<")) {
     parsedType.type = parsedType.type.slice(7, -1);
-    if (!ctx.typesMap[parsedType.type]) throw new Error(`Unexpected property type: '${parsedType.type}'`);
+    if (!ctx.typeNodesMap[parsedType.type]) throw new Error(`Unexpected property type: '${parsedType.type}'`);
     parsedType.isChange = true;
   } else {
-    if (!supportedPrimitiveTypes.includes(parsedType.type) && !ctx.typesMap[parsedType.type] && !ctx.result[parsedType.type] && parsedType.type !== "thisReference") {
+    if (!supportedPrimitiveTypes.includes(parsedType.type) && !ctx.typeNodesMap[parsedType.type] && !ctx.result[parsedType.type]) {
       throw new Error(`Unexpected property type: '${parsedType.type}'`);
     }
   }
-  if (defaultValueDescription && defaultValueDescription.type !== "thisReference") {
-    verifyDefaultValueType(parsedType.isArray, defaultValueDescription, parsedType.type, supportedPrimitiveTypes, ctx);
-  }
   return {
     isArray: parsedType.isArray || void 0,
     isRelation: parsedType.isRelation || void 0,
@@ -286,9 +338,9 @@ function parseFieldTypeRecordEnum(parsedType, parentName, fieldName, ctx) {
   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.typesMap[keyTypeName];
+  const keyType = ctx.typeNodesMap[keyTypeName];
   if (!keyType) return;
-  if (!ctx.result[keyTypeName]) ctx.result[keyTypeName] = parseType(keyType.node, keyTypeName, ctx);
+  if (!ctx.result[keyTypeName]) ctx.result[keyTypeName] = parseClassOrTypeDeclaration(keyType.node, keyTypeName, ctx);
   const enumValues = ctx.result[keyTypeName].enumValues;
   if (!enumValues) throw new Error(`Unexpected type - ${keyTypeName}`);
   const newTypeName = `${parentName}_${_lodash.default.upperFirst(fieldName)}`;
@@ -362,11 +414,11 @@ function getEnumValuesFromKeyOf(nodeType, ctx) {
     throw new Error(`Unexpected type - ${typeReferenceNode.getText(ctx.sourceFile)}`);
   }
   const typeName = typeReferenceNode.typeName.text;
-  const type = ctx.typesMap[typeName];
+  const type = ctx.typeNodesMap[typeName];
   if (!type) {
     throw new Error(`Unexpected type - ${typeName}`);
   }
-  if (!ctx.result[typeName]) ctx.result[typeName] = parseType(type.node, typeName, ctx);
+  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 => ({
     name: v.name,
@@ -388,23 +440,43 @@ function getRelationDenormFields(ctx, node) {
   }
   throw new Error(`Unexpected type - ${node.getText(ctx.sourceFile)}`);
 }
-function verifyDefaultValueType(isArray, defaultValueDescription, type, supportedPrimitiveTypes2, ctx) {
+function verifyDefaultValueType(field, ctx) {
+  const {
+    isArray,
+    defaultValue,
+    type
+  } = field;
   if (isArray) {
-    if (defaultValueDescription.type !== "array") {
-      throw new Error(`Default value type is different from field type: '${type}'`);
+    if (!_lodash.default.isArray(defaultValue)) {
+      throw new TypeError(`Default value type is different from field type: '${type}'`);
     }
   } else {
-    if (supportedPrimitiveTypes2.includes(type) && defaultValueDescription.type !== type) {
+    if (supportedPrimitiveTypes.includes(type) && getPrimitiveTypeFromDefaultValue(defaultValue) !== type) {
       throw new Error(`Default value type is different from field type: '${type}'`);
     }
-    if (!ctx.result[type] && ctx.typesMap[type]) ctx.result[type] = parseType(ctx.typesMap[type].node, type, ctx);
+    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[defaultValueDescription.value]) {
+    if (enumValues && !enumValues[defaultValue]) {
       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) {
+  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, ctx) {
   const expr = decoratorNode.expression;
   if (expr.kind !== _typescript.SyntaxKind.CallExpression) throw new Error(`Unexpected decorator format: "${expr.getText(ctx.sourceFile)}"`);
@@ -420,40 +492,35 @@ function parseDecoratorArguments(expr, ctx) {
   if (args.length === 0) return {};
   if (args.length > 1) throw new Error(`Too many arguments - one expected: "${expr.getText(ctx.sourceFile)}"`);
   const arg = args[0];
-  return parseLiteralNode(arg, ctx)?.value ?? {};
+  return parseLiteralNode(arg, ctx) ?? {};
 }
-function parseLiteralNode(expr, ctx) {
-  if (!expr) return void 0;
+function parseDefaultValueExpression(expr, ctx) {
+  if (!expr) return {};
   if (expr.kind === _typescript.SyntaxKind.NewExpression) {
     const identifier = expr.expression;
     const type = identifier?.text;
     if (type) {
       return {
-        type,
-        value: {}
+        defaultValueClass: type,
+        defaultValue: {}
       };
     }
+  } else if (expr.kind === _typescript.SyntaxKind.PropertyAccessExpression && expr.expression.kind === _typescript.SyntaxKind.ThisKeyword) {
+    return {
+      defaultValueCopyFrom: expr.name?.text
+    };
   }
-  if (expr.kind === _typescript.SyntaxKind.StringLiteral) return {
-    type: "string",
-    value: expr.text
-  };
-  if (expr.kind === _typescript.SyntaxKind.FalseKeyword) return {
-    type: "boolean",
-    value: false
-  };
-  if (expr.kind === _typescript.SyntaxKind.TrueKeyword) return {
-    type: "boolean",
-    value: true
-  };
-  if (expr.kind === _typescript.SyntaxKind.NumericLiteral) return {
-    type: "number",
-    value: Number.parseFloat(expr.text)
-  };
-  if (expr.kind === _typescript.SyntaxKind.ObjectLiteralExpression) return {
-    type: "object",
-    value: parseObjectLiteral(expr, ctx)
+  return {
+    defaultValue: parseLiteralNode(expr, ctx)
   };
+}
+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;
@@ -463,16 +530,7 @@ function parseLiteralNode(expr, ctx) {
       throw new Error("Value must be valid array");
     }
     if (!_lodash.default.isArray(defaultValue)) throw new Error("Value must be valid array");
-    return {
-      type: "array",
-      value: defaultValue
-    };
-  }
-  if (expr.kind === _typescript.SyntaxKind.PropertyAccessExpression && expr.expression.kind === _typescript.SyntaxKind.ThisKeyword) {
-    return {
-      type: "thisReference",
-      value: expr.name?.text
-    };
+    return defaultValue;
   }
   throw new Error(`Unexpected property expression: "${expr.getText(ctx.sourceFile)}"`);
 }
@@ -485,7 +543,7 @@ function parseObjectLiteral(arg, ctx) {
     if (p.kind !== _typescript.SyntaxKind.PropertyAssignment) throw new Error(`Unexpected property value: "${p.getText(ctx.sourceFile)}"`);
     const p2 = p;
     const valueExpression = p2.initializer;
-    const value = parseLiteralNode(valueExpression, ctx)?.value;
+    const value = parseLiteralNode(valueExpression, ctx);
     result[name] = value;
   }
   return result;

package/integrations/lib.d.ts

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

package/integrations/lib.mjs

@@ -3,8 +3,58 @@ import _ from "lodash";
 import pluralize from "pluralize";
 const supportedPrimitiveTypes = ["string", "number", "boolean", "Record<string, string>", "Record<string, any>"];
 export 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 = {};
-  const typesMap = {};
+  for (const key in typeNodesMap) {
+    const { node, name } = typeNodesMap[key];
+    if (![SyntaxKind.ClassDeclaration, 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 !== 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 !== 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 = createSourceFile(`${key}.ts`, text, ScriptTarget.Latest);
@@ -14,61 +64,41 @@ export function parseSchema(typescriptFiles) {
       if (!nameNode || nameNode.kind !== SyntaxKind.Identifier)
         throw new Error("Cannot detect class name");
       const name = nameNode.text;
-      typesMap[name] = { name, node: cd, sourceFile };
+      typeNodesMap[name] = { name, node: cd, sourceFile };
     }
-    if (!typesMap[key]) {
+    if (!typeNodesMap[key]) {
       throw new Error(`File ${key}.ts must contain class declaration with name "${key}"`);
     }
   }
-  for (const key in typesMap) {
-    if (result[key])
-      continue;
-    const { node, sourceFile, name } = typesMap[key];
-    const parsedClass = parseType(node, name, { typesMap, sourceFile, result });
-    if (parsedClass.name !== key)
-      throw new Error(`File name must correspond to exported class name ("${key}", "${parsedClass.name}")`);
-    result[key] = parsedClass;
-  }
-  for (const key in result) {
-    const isExtendingType = result[key].isExtending;
-    if (!isExtendingType)
-      continue;
-    if (!result[isExtendingType])
-      throw new Error(`Unknown type: "${isExtendingType}"`);
-    result[key].fields = { ...result[isExtendingType].fields, ...result[key].fields };
-    result[key].decorators = { ...result[isExtendingType].decorators, ...result[key].decorators };
-    if (result[key].decorators.entity && !result[key].fields?.id) {
-      throw new Error(`Entity "${key}" must have an id`);
-    }
-  }
-  fillComputedDefinitionsForType(result);
-  processThisReferenceDefaultValues(result, typesMap);
-  verifyRelationFields(result);
-  return result;
+  return typeNodesMap;
 }
-function processThisReferenceDefaultValues(result, typesMap) {
-  for (const key in result) {
-    const type = result[key];
+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.defaultValueCopyFrom) {
-        const sourceField = fields[field.defaultValueCopyFrom];
-        if (!sourceField)
-          throw new Error(`Cannot find field ${key}.${field.defaultValueCopyFrom}"`);
-        if (field.type === "thisReference") {
-          field.type = sourceField.type;
-          field.isArray = sourceField.isArray;
+      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
+          });
         }
-        verifyDefaultValueType(
-          field.isArray || false,
-          { type: sourceField.type, value: sourceField.defaultValue },
-          field.type,
-          supportedPrimitiveTypes,
-          { typesMap, result, sourceFile: typesMap[key]?.sourceFile }
-        );
       }
     }
   }
@@ -98,7 +128,14 @@ function getOrder(f) {
   };
   return decorator.order ?? defaultOrders[decorator.preset] ?? 0;
 }
-function parseType(typeDeclaration, typeName, ctx) {
+function parseClassOrTypeDeclaration(typeDeclaration, typeName, ctx) {
+  if (typeDeclaration.kind === SyntaxKind.ClassDeclaration)
+    return parseClassDeclaration(typeDeclaration, typeName, ctx);
+  if (typeDeclaration.kind === SyntaxKind.TypeAliasDeclaration)
+    return parseTypeAliasDeclaration(typeDeclaration, typeName, ctx);
+  throw new Error(`Unexpected type definition - ${typeName}`);
+}
+function parseClassDeclaration(typeDeclaration, typeName, ctx) {
   if (ctx.result[typeName])
     return ctx.result[typeName];
   const { modifiers } = typeDeclaration;
@@ -108,49 +145,53 @@ function parseType(typeDeclaration, typeName, ctx) {
   const name = nameNode.text;
   const comment = typeDeclaration.jsDoc?.[0]?.comment;
   const decorators = parseDecorators(modifiers, ctx);
-  if (typeDeclaration.kind === SyntaxKind.ClassDeclaration) {
-    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)}")`);
-      }
+  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)}")`);
     }
-    const fieldsArray = members.map((m) => parseClassMember(m, name, ctx));
-    const fields = {};
-    for (const f of fieldsArray) {
-      fields[f.name] = f;
-    }
-    const handle = _.lowerFirst(name);
-    const handlePlural = pluralize(handle);
-    const result = {
-      name,
-      handle,
-      handlePlural,
-      decorators,
-      fields,
-      isExtending,
-      comment
-    };
-    return result;
   }
-  if (typeDeclaration.kind === SyntaxKind.TypeAliasDeclaration) {
-    const typeAliasDeclaration = typeDeclaration;
-    const typeAliasType = typeAliasDeclaration.type;
-    if (typeAliasType.kind === SyntaxKind.UnionType) {
-      const typeAliasValue = typeAliasDeclaration.type;
-      const enumValues = getEnumValues(typeAliasValue, typeDeclaration, ctx);
-      return { name, decorators, enumValues, comment };
-    }
-    if (typeAliasType.kind === SyntaxKind.TypeOperator && typeAliasType.operator === SyntaxKind.KeyOfKeyword) {
-      const enumValues = getEnumValuesFromKeyOf(typeAliasType, ctx);
-      return { name, decorators, enumValues, comment };
-    }
-    throw new Error(`Unexpected type definition - ${typeDeclaration.getText(ctx.sourceFile)}. Did you mean 'class'?`);
+  const fields = {};
+  for (const m of members) {
+    const field = parseClassMember(m, fields, name, ctx);
+    fields[field.name] = field;
   }
-  throw new Error(`Unexpected type kind - "${name}"`);
+  const handle = _.lowerFirst(name);
+  const handlePlural = pluralize(handle);
+  const result = {
+    name,
+    handle,
+    handlePlural,
+    decorators,
+    fields,
+    isExtending,
+    comment
+  };
+  return result;
+}
+function parseTypeAliasDeclaration(typeDeclaration, typeName, ctx) {
+  if (ctx.result[typeName])
+    return ctx.result[typeName];
+  const nameNode = typeDeclaration.name;
+  if (!nameNode || nameNode.kind !== SyntaxKind.Identifier)
+    throw new Error("Cannot detect class name");
+  const name = nameNode.text;
+  const comment = typeDeclaration.jsDoc?.[0]?.comment;
+  const typeAliasDeclaration = typeDeclaration;
+  const typeAliasType = typeAliasDeclaration.type;
+  if (typeAliasType.kind === SyntaxKind.UnionType) {
+    const typeAliasValue = typeAliasDeclaration.type;
+    const enumValues = getEnumValues(typeAliasValue, typeDeclaration, ctx);
+    return { name, enumValues, comment, decorators: {} };
+  }
+  if (typeAliasType.kind === SyntaxKind.TypeOperator && typeAliasType.operator === SyntaxKind.KeyOfKeyword) {
+    const enumValues = getEnumValuesFromKeyOf(typeAliasType, ctx);
+    return { name, enumValues, comment, decorators: {} };
+  }
+  throw new Error(`Unexpected type definition - ${typeDeclaration.getText(ctx.sourceFile)}. Did you mean 'class'?`);
 }
 function parseDecorators(modifiers, ctx) {
   if (!modifiers)
@@ -175,27 +216,25 @@ function getEnumValues(node, parentNode, ctx) {
   });
   return _.keyBy(enumValuesArray, "name");
 }
-function parseClassMember(node, parentName, ctx) {
+function parseClassMember(node, parentFields, parentName, ctx) {
   const name = node.name.getText(ctx.sourceFile);
-  const defaultValueDescription = parseLiteralNode(node.initializer, ctx);
-  let defaultValue;
-  let defaultValueCopyFrom;
-  if (defaultValueDescription) {
-    if (defaultValueDescription.type === "thisReference") {
-      defaultValueCopyFrom = defaultValueDescription.value;
-    } else {
-      defaultValue = defaultValueDescription.value;
-    }
-  }
+  const { defaultValue, defaultValueCopyFrom, defaultValueClass } = parseDefaultValueExpression(node.initializer, ctx);
   const isRequired = !node.questionToken;
   const comment = node.jsDoc?.[0]?.comment;
   const decorators = parseDecorators(node.modifiers, ctx);
+  let defaultValueType = defaultValueClass || getPrimitiveTypeFromDefaultValue(defaultValue);
+  if (defaultValueCopyFrom) {
+    const parentField = parentFields[defaultValueCopyFrom];
+    if (!parentField)
+      throw new Error(`Cannot find field ${parentName}.${defaultValueCopyFrom}"`);
+    defaultValueType = parentField.type;
+  }
   const { isArray, isRelation, isChange, relationDenormFields, type } = parseFieldType(
     ctx,
     parentName,
     name,
     node,
-    defaultValueDescription
+    defaultValueType
   );
   const result = {
     type,
@@ -211,9 +250,24 @@ function parseClassMember(node, parentName, ctx) {
   };
   if (!_.isEmpty(decorators))
     result.decorators = decorators;
+  if (defaultValueClass)
+    result.defaultValueClass = defaultValueClass;
   return result;
 }
-function parseFieldType(ctx, parentName, fieldName, node, defaultValueDescription) {
+function getPrimitiveTypeFromDefaultValue(value) {
+  if (_.isString(value))
+    return "string";
+  if (_.isNumber(value))
+    return "number";
+  if (_.isBoolean(value))
+    return "boolean";
+  if (_.isArray(value))
+    return "array";
+  if (_.isObject(value))
+    return "object";
+  return void 0;
+}
+function parseFieldType(ctx, parentName, fieldName, node, defaultValueType) {
   const parsedType = {
     isArray: false,
     isRelation: false,
@@ -228,22 +282,19 @@ function parseFieldType(ctx, parentName, fieldName, node, defaultValueDescriptio
   parseFieldTypeInlineEnum(parsedType, parentName, fieldName, ctx);
   parseFieldTypeKeyofEnum(parsedType, parentName, fieldName, ctx);
   parseFieldTypeRecordEnum(parsedType, parentName, fieldName, ctx);
-  parsedType.type = parsedType.type ?? parsedType.nodeType?.getText(ctx.sourceFile) ?? defaultValueDescription?.type;
+  parsedType.type = parsedType.type ?? parsedType.nodeType?.getText(ctx.sourceFile) ?? defaultValueType;
   if (!parsedType.type)
     throw new Error(`Cannot detect property type: '${node.getText(ctx.sourceFile)}'`);
   if (parsedType.type.startsWith("Change<")) {
     parsedType.type = parsedType.type.slice(7, -1);
-    if (!ctx.typesMap[parsedType.type])
+    if (!ctx.typeNodesMap[parsedType.type])
       throw new Error(`Unexpected property type: '${parsedType.type}'`);
     parsedType.isChange = true;
   } else {
-    if (!supportedPrimitiveTypes.includes(parsedType.type) && !ctx.typesMap[parsedType.type] && !ctx.result[parsedType.type] && parsedType.type !== "thisReference") {
+    if (!supportedPrimitiveTypes.includes(parsedType.type) && !ctx.typeNodesMap[parsedType.type] && !ctx.result[parsedType.type]) {
       throw new Error(`Unexpected property type: '${parsedType.type}'`);
     }
   }
-  if (defaultValueDescription && defaultValueDescription.type !== "thisReference") {
-    verifyDefaultValueType(parsedType.isArray, defaultValueDescription, parsedType.type, supportedPrimitiveTypes, ctx);
-  }
   return {
     isArray: parsedType.isArray || void 0,
     isRelation: parsedType.isRelation || void 0,
@@ -262,11 +313,11 @@ function parseFieldTypeRecordEnum(parsedType, parentName, fieldName, ctx) {
     return;
   const keyTypeName = nt.typeArguments[0].getText(ctx.sourceFile);
   const valueTypeName = nt.typeArguments[1].getText(ctx.sourceFile);
-  const keyType = ctx.typesMap[keyTypeName];
+  const keyType = ctx.typeNodesMap[keyTypeName];
   if (!keyType)
     return;
   if (!ctx.result[keyTypeName])
-    ctx.result[keyTypeName] = parseType(keyType.node, keyTypeName, ctx);
+    ctx.result[keyTypeName] = parseClassOrTypeDeclaration(keyType.node, keyTypeName, ctx);
   const enumValues = ctx.result[keyTypeName].enumValues;
   if (!enumValues)
     throw new Error(`Unexpected type - ${keyTypeName}`);
@@ -335,12 +386,12 @@ function getEnumValuesFromKeyOf(nodeType, ctx) {
     throw new Error(`Unexpected type - ${typeReferenceNode.getText(ctx.sourceFile)}`);
   }
   const typeName = typeReferenceNode.typeName.text;
-  const type = ctx.typesMap[typeName];
+  const type = ctx.typeNodesMap[typeName];
   if (!type) {
     throw new Error(`Unexpected type - ${typeName}`);
   }
   if (!ctx.result[typeName])
-    ctx.result[typeName] = parseType(type.node, typeName, ctx);
+    ctx.result[typeName] = parseClassOrTypeDeclaration(type.node, typeName, ctx);
   if (!ctx.result[typeName].fields)
     throw new Error(`Unexpected type - ${typeName}`);
   return _.mapValues(ctx.result[typeName].fields || {}, (v) => ({
@@ -363,24 +414,37 @@ function getRelationDenormFields(ctx, node) {
   }
   throw new Error(`Unexpected type - ${node.getText(ctx.sourceFile)}`);
 }
-function verifyDefaultValueType(isArray, defaultValueDescription, type, supportedPrimitiveTypes2, ctx) {
+function verifyDefaultValueType(field, ctx) {
+  const { isArray, defaultValue, type } = field;
   if (isArray) {
-    if (defaultValueDescription.type !== "array") {
-      throw new Error(`Default value type is different from field type: '${type}'`);
+    if (!_.isArray(defaultValue)) {
+      throw new TypeError(`Default value type is different from field type: '${type}'`);
     }
   } else {
-    if (supportedPrimitiveTypes2.includes(type) && defaultValueDescription.type !== type) {
+    if (supportedPrimitiveTypes.includes(type) && getPrimitiveTypeFromDefaultValue(defaultValue) !== type) {
       throw new Error(`Default value type is different from field type: '${type}'`);
     }
-    if (!ctx.result[type] && ctx.typesMap[type])
-      ctx.result[type] = parseType(ctx.typesMap[type].node, type, ctx);
+    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[defaultValueDescription.value]) {
+    if (enumValues && !enumValues[defaultValue]) {
       const enumValuesStr = _.keys(enumValues).map((x) => `'x'`).join(", ");
       throw new Error(`Default value must be one of: ${enumValuesStr}`);
     }
   }
 }
+function verifyDefaultValueTypeCopyFrom(field, sourceField, ctx) {
+  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, ctx) {
   const expr = decoratorNode.expression;
   if (expr.kind !== SyntaxKind.CallExpression)
@@ -397,28 +461,35 @@ function parseDecoratorArguments(expr, ctx) {
   if (args.length > 1)
     throw new Error(`Too many arguments - one expected: "${expr.getText(ctx.sourceFile)}"`);
   const arg = args[0];
-  return parseLiteralNode(arg, ctx)?.value ?? {};
+  return parseLiteralNode(arg, ctx) ?? {};
 }
-function parseLiteralNode(expr, ctx) {
+function parseDefaultValueExpression(expr, ctx) {
   if (!expr)
-    return void 0;
+    return {};
   if (expr.kind === SyntaxKind.NewExpression) {
     const identifier = expr.expression;
     const type = identifier?.text;
     if (type) {
-      return { type, value: {} };
+      return { defaultValueClass: type, defaultValue: {} };
     }
+  } else if (expr.kind === SyntaxKind.PropertyAccessExpression && expr.expression.kind === SyntaxKind.ThisKeyword) {
+    return { defaultValueCopyFrom: expr.name?.text };
   }
+  return { defaultValue: parseLiteralNode(expr, ctx) };
+}
+function parseLiteralNode(expr, ctx) {
+  if (!expr)
+    return void 0;
   if (expr.kind === SyntaxKind.StringLiteral)
-    return { type: "string", value: expr.text };
+    return expr.text;
   if (expr.kind === SyntaxKind.FalseKeyword)
-    return { type: "boolean", value: false };
+    return false;
   if (expr.kind === SyntaxKind.TrueKeyword)
-    return { type: "boolean", value: true };
+    return true;
   if (expr.kind === SyntaxKind.NumericLiteral)
-    return { type: "number", value: Number.parseFloat(expr.text) };
+    return Number.parseFloat(expr.text);
   if (expr.kind === SyntaxKind.ObjectLiteralExpression)
-    return { type: "object", value: parseObjectLiteral(expr, ctx) };
+    return parseObjectLiteral(expr, ctx);
   if (expr.kind === SyntaxKind.ArrayLiteralExpression) {
     const defaultValueStr = expr.getText(ctx.sourceFile);
     let defaultValue;
@@ -429,10 +500,7 @@ function parseLiteralNode(expr, ctx) {
     }
     if (!_.isArray(defaultValue))
       throw new Error("Value must be valid array");
-    return { type: "array", value: defaultValue };
-  }
-  if (expr.kind === SyntaxKind.PropertyAccessExpression && expr.expression.kind === SyntaxKind.ThisKeyword) {
-    return { type: "thisReference", value: expr.name?.text };
+    return defaultValue;
   }
   throw new Error(`Unexpected property expression: "${expr.getText(ctx.sourceFile)}"`);
 }
@@ -447,7 +515,7 @@ function parseObjectLiteral(arg, ctx) {
       throw new Error(`Unexpected property value: "${p.getText(ctx.sourceFile)}"`);
     const p2 = p;
     const valueExpression = p2.initializer;
-    const value = parseLiteralNode(valueExpression, ctx)?.value;
+    const value = parseLiteralNode(valueExpression, ctx);
     result[name] = value;
   }
   return result;

package/integrations/restEndpointsDev.cjs

@@ -77,6 +77,11 @@ var _default = {
   async unlink(filepath) {
     sanitizeFilepath(filepath);
     return await _promises.default.unlink(filepath);
+  },
+  async rename(oldFilepath, newFilepath) {
+    sanitizeFilepath(oldFilepath);
+    sanitizeFilepath(newFilepath);
+    return await _promises.default.rename(oldFilepath, newFilepath);
   }
 };
 module.exports = _default;

package/integrations/restEndpointsDev.d.ts

@@ -19,5 +19,6 @@ declare const _default: {
     lstat(filepath: string, options?: any): Promise<any>;
     /** Delete a file */
     unlink(filepath: string): Promise<any>;
+    rename(oldFilepath: string, newFilepath: string): Promise<any>;
 };
 export default _default;

package/integrations/restEndpointsDev.mjs

@@ -69,6 +69,11 @@ export default {
   async unlink(filepath) {
     sanitizeFilepath(filepath);
     return await fs.unlink(filepath);
+  },
+  async rename(oldFilepath, newFilepath) {
+    sanitizeFilepath(oldFilepath);
+    sanitizeFilepath(newFilepath);
+    return await fs.rename(oldFilepath, newFilepath);
   }
 };
 async function dirExists(path2) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rads-db",
-  "version": "3.0.18",
+  "version": "3.0.20",
   "files": [
     "dist",
     "drivers",