rads-db 3.0.19 → 3.0.21

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/package.json

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