rads-db 3.0.19 → 3.0.21

package/drivers/memory.mjs

@@ -31,20 +31,37 @@ const operatorFns = {
   }
 };
 export default (options) => (schema, entity) => {
-  let itemsById = {};
+  const itemsById = {};
   function getItemById(id) {
     return itemsById[id] ?? null;
   }
   function getItemByIds(ids) {
     return ids.map((id) => itemsById[id]);
   }
+  function getMany(args) {
+    args = args || {};
+    const where = args.where || {};
+    const whereKeys = _.keys(where);
+    if (whereKeys.length === 1) {
+      if (whereKeys[0] === "id")
+        return { nodes: _.cloneDeep([getItemById(where.id)].filter((x) => x)), cursor: null };
+      if (whereKeys[0] === "id_in")
+        return { nodes: _.cloneDeep(getItemByIds(where.id_in).filter((x) => x)), cursor: null };
+    }
+    return queryArray(Object.values(itemsById), args);
+  }
   const instance = {
     driverName: "memory",
     get itemsById() {
       return itemsById;
     },
-    clear() {
-      itemsById = {};
+    getMany,
+    deleteMany(args) {
+      const { nodes, cursor } = getMany(args);
+      for (const node of nodes) {
+        delete itemsById[node.id];
+      }
+      return { nodes, cursor };
     },
     putMany(items) {
       for (const item of items) {
@@ -52,18 +69,6 @@ export default (options) => (schema, entity) => {
           throw new Error(`You must provide an id`);
         itemsById[item.id] = item;
       }
-    },
-    getMany(args) {
-      args = args || {};
-      const where = args.where || {};
-      const whereKeys = _.keys(where);
-      if (whereKeys.length === 1) {
-        if (whereKeys[0] === "id")
-          return { nodes: _.cloneDeep([getItemById(where.id)].filter((x) => x)), cursor: null };
-        if (whereKeys[0] === "id_in")
-          return { nodes: _.cloneDeep(getItemByIds(where.id_in).filter((x) => x)), cursor: null };
-      }
-      return queryArray(Object.values(itemsById), args);
     }
   };
   return instance;

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>;