rads-db 3.0.3 → 3.0.6

package/dist/index.cjs

@@ -1017,7 +1017,7 @@ function generateMethods(schema, validators, options) {
       typeName: key,
       handle: schema[key].handle
     };
-    const driverInstance = getDriverInstance(schema, key, opts.driver, drivers);
+    const driverInstance = getDriverInstance(schema, key, getDriverConstructor(opts, schema, key), drivers);
     db[handle] = getRadsDbMethods(key, computedContext, driverInstance);
   }
   for (const f of opts.features) {
@@ -1026,18 +1026,13 @@ function generateMethods(schema, validators, options) {
   }
   return db;
 }
-function getDriverInstance(schema, key, driver, driverInstances) {
+function getDriverInstance(schema, key, driverConstructor, driverInstances) {
   if (!driverInstances[key]) {
-    driverInstances[key] = getDriverInstanceInner(schema, key, driver);
+    driverInstances[key] = getDriverInstanceInner(schema, key, driverConstructor);
   }
   return driverInstances[key];
 }
-function getDriverInstanceInner(schema, key, drivers) {
-  const driverName = schema[key].decorators.entity.driver || "default";
-  const driverConstructor = drivers[driverName];
-  if (!driverConstructor) {
-    throw new Error(`Missing driver "${driverName}" for entity "${key}"`);
-  }
+function getDriverInstanceInner(schema, key, driverConstructor) {
   const driverInstance = driverConstructor(schema, key);
   addDryRunSupport(driverInstance, key);
   async function getAll(args, ctx) {
@@ -1142,6 +1137,17 @@ function normalizeOptions(options) {
     driver = { default: driver };
   return { computed: {}, features: [], ...options, driver };
 }
+function getDriverConstructor(options, schema, key) {
+  let driverName = "default";
+  if (!options.noCustomDrivers) {
+    driverName = schema[key].decorators.entity.driver || driverName;
+  }
+  const driverConstructor = options.driver[driverName];
+  if (!driverConstructor) {
+    throw new Error(`Missing driver "${driverName}" for entity "${key}"`);
+  }
+  return driverConstructor;
+}
 
 const restApi = (options) => (schema, entity) => {
   const opts = {

package/dist/index.d.ts

@@ -86,6 +86,7 @@ interface EntityMethods<E, EN extends keyof EntityMeta, W> {
 }
 
 type MaybePromise<T> = Promise<T> | T;
+type RequiredFields<T, K extends keyof T> = T & Required<Pick<T, K>>;
 type ValidateFieldDecoratorArgs<T> = T extends string ? ValidateStringDecoratorArgs : T extends number ? ValidateNumberDecoratorArgs : ValidateAnyDecoratorArgs;
 interface ValidateEntityDecoratorArgs {
 }
@@ -182,6 +183,9 @@ interface CreateRadsDbArgs {
     context?: Record<string, any> & Omit<RadsRequestContext, 'dryRun' | 'silent'>;
     features?: RadsFeature[];
 }
+type CreateRadsDbArgsNormalized = RequiredFields<CreateRadsDbArgs, 'computed' | 'features'> & {
+    driver: CreateRadsArgsDrivers;
+};
 type CreateRadsDbClientArgs = Omit<CreateRadsDbArgs, 'noComputed' | 'noCustomDrivers' | 'driver'> & {
     driver?: RestDriverOptions;
 };
@@ -359,7 +363,7 @@ declare function field(meta?: FieldDecoratorArgs): (a: any, b?: ClassFieldDecora
 declare function precomputed(meta?: ComputedDecoratorArgs): (a: any, b?: ClassFieldDecoratorContext | ClassDecoratorContext) => void;
 declare function computed(meta?: ComputedDecoratorArgs): (a: any, b?: ClassFieldDecoratorContext | ClassDecoratorContext) => void;
 
-declare function getDriverInstance(schema: Schema, key: string, driver: CreateRadsArgsDrivers, driverInstances: Record<string, Driver>): Driver;
+declare function getDriverInstance(schema: Schema, key: string, driverConstructor: DriverConstructor, driverInstances: Record<string, Driver>): Driver;
 
 /**
  * Creates instance of rads db - object that provides access to all entities.
@@ -373,4 +377,4 @@ declare function createRadsDb(args?: CreateRadsDbArgs): RadsDb;
  */
 declare function createRadsDbClient(args?: CreateRadsDbClientArgs): RadsDb;
 
-export { Change, ComputedContext, ComputedContextGlobal, ComputedDecoratorArgs, CreateRadsArgsDrivers, CreateRadsDbArgs, CreateRadsDbClientArgs, DeepPartial, Driver, DriverConstructor, EntityDecoratorArgs, EntityMethods, FieldDecoratorArgs, FieldDefinition, FileSystemNode, FileUploadArgs, FileUploadDriver, GenerateClientNormalizedOptions, GenerateClientOptions, GetAggArgs, GetAggArgsAgg, GetAggArgsAny, GetAggResponse, GetArgs, GetArgsAny, GetArgsInclude, GetManyArgs, GetManyArgsAny, GetManyResponse, GetResponse, GetResponseInclude, GetResponseIncludeSelect, GetResponseNoInclude, GetRestRoutesArgs, GetRestRoutesOptions, GetRestRoutesResponse, MinimalDriver, PutArgs, PutEffect, RadsFeature, RadsRequestContext, RadsUiSlotDefinition, RadsUiSlotName, RadsVitePluginOptions, Relation, RestDriverOptions, RestFileUploadDriverOptions, Schema, SchemaValidators, TypeDefinition, UiDecoratorArgs, UiFieldDecoratorArgs, ValidateEntityDecoratorArgs, ValidateFieldDecoratorArgs, ValidateStringDecoratorArgs, VerifyManyArgs, VerifyManyArgsAny, VerifyManyResponse, computed, createRadsDb, createRadsDbClient, entity, field, getDriverInstance, precomputed, ui, validate };
+export { Change, ComputedContext, ComputedContextGlobal, ComputedDecoratorArgs, CreateRadsArgsDrivers, CreateRadsDbArgs, CreateRadsDbArgsNormalized, CreateRadsDbClientArgs, DeepPartial, Driver, DriverConstructor, EntityDecoratorArgs, EntityMethods, FieldDecoratorArgs, FieldDefinition, FileSystemNode, FileUploadArgs, FileUploadDriver, GenerateClientNormalizedOptions, GenerateClientOptions, GetAggArgs, GetAggArgsAgg, GetAggArgsAny, GetAggResponse, GetArgs, GetArgsAny, GetArgsInclude, GetManyArgs, GetManyArgsAny, GetManyResponse, GetResponse, GetResponseInclude, GetResponseIncludeSelect, GetResponseNoInclude, GetRestRoutesArgs, GetRestRoutesOptions, GetRestRoutesResponse, MinimalDriver, PutArgs, PutEffect, RadsFeature, RadsRequestContext, RadsUiSlotDefinition, RadsUiSlotName, RadsVitePluginOptions, Relation, RequiredFields, RestDriverOptions, RestFileUploadDriverOptions, Schema, SchemaValidators, TypeDefinition, UiDecoratorArgs, UiFieldDecoratorArgs, ValidateEntityDecoratorArgs, ValidateFieldDecoratorArgs, ValidateStringDecoratorArgs, VerifyManyArgs, VerifyManyArgsAny, VerifyManyResponse, computed, createRadsDb, createRadsDbClient, entity, field, getDriverInstance, precomputed, ui, validate };

package/dist/index.mjs

@@ -1009,7 +1009,7 @@ function generateMethods(schema, validators, options) {
       typeName: key,
       handle: schema[key].handle
     };
-    const driverInstance = getDriverInstance(schema, key, opts.driver, drivers);
+    const driverInstance = getDriverInstance(schema, key, getDriverConstructor(opts, schema, key), drivers);
     db[handle] = getRadsDbMethods(key, computedContext, driverInstance);
   }
   for (const f of opts.features) {
@@ -1018,18 +1018,13 @@ function generateMethods(schema, validators, options) {
   }
   return db;
 }
-function getDriverInstance(schema, key, driver, driverInstances) {
+function getDriverInstance(schema, key, driverConstructor, driverInstances) {
   if (!driverInstances[key]) {
-    driverInstances[key] = getDriverInstanceInner(schema, key, driver);
+    driverInstances[key] = getDriverInstanceInner(schema, key, driverConstructor);
   }
   return driverInstances[key];
 }
-function getDriverInstanceInner(schema, key, drivers) {
-  const driverName = schema[key].decorators.entity.driver || "default";
-  const driverConstructor = drivers[driverName];
-  if (!driverConstructor) {
-    throw new Error(`Missing driver "${driverName}" for entity "${key}"`);
-  }
+function getDriverInstanceInner(schema, key, driverConstructor) {
   const driverInstance = driverConstructor(schema, key);
   addDryRunSupport(driverInstance, key);
   async function getAll(args, ctx) {
@@ -1134,6 +1129,17 @@ function normalizeOptions(options) {
     driver = { default: driver };
   return { computed: {}, features: [], ...options, driver };
 }
+function getDriverConstructor(options, schema, key) {
+  let driverName = "default";
+  if (!options.noCustomDrivers) {
+    driverName = schema[key].decorators.entity.driver || driverName;
+  }
+  const driverConstructor = options.driver[driverName];
+  if (!driverConstructor) {
+    throw new Error(`Missing driver "${driverName}" for entity "${key}"`);
+  }
+  return driverConstructor;
+}
 
 const restApi = (options) => (schema, entity) => {
   const opts = {

package/features/cache.cjs

@@ -56,9 +56,7 @@ var _default = options => {
           handle: cacheEntityName,
           handlePlural: `${cacheEntityName}s`
         };
-        cacheDrivers[handle] = (0, _radsDb.getDriverInstance)(schema, cacheEntityName, {
-          default: normalizedOptions[typeName].driver
-        }, drivers);
+        cacheDrivers[handle] = (0, _radsDb.getDriverInstance)(schema, cacheEntityName, normalizedOptions[typeName].driver, drivers);
         cacheStatus[handle] = {
           preloadStatus: normalizedOptions[typeName].preload ? "neverLoaded" : void 0
         };

package/features/cache.mjs

@@ -38,12 +38,7 @@ export default (options) => {
           handle: cacheEntityName,
           handlePlural: `${cacheEntityName}s`
         };
-        cacheDrivers[handle] = getDriverInstance(
-          schema,
-          cacheEntityName,
-          { default: normalizedOptions[typeName].driver },
-          drivers
-        );
+        cacheDrivers[handle] = getDriverInstance(schema, cacheEntityName, normalizedOptions[typeName].driver, drivers);
         cacheStatus[handle] = { preloadStatus: normalizedOptions[typeName].preload ? "neverLoaded" : void 0 };
       }
       db.cache = {

package/integrations/lib.cjs

@@ -114,6 +114,7 @@ function getOrder(f) {
   return decorator.order ?? defaultOrders[decorator.preset] ?? 0;
 }
 function parseType(typeDeclaration, typeName, ctx) {
+  if (ctx.result[typeName]) return ctx.result[typeName];
   const {
     modifiers
   } = typeDeclaration;
@@ -155,15 +156,27 @@ function parseType(typeDeclaration, typeName, ctx) {
   }
   if (typeDeclaration.kind === _typescript.SyntaxKind.TypeAliasDeclaration) {
     const typeAliasDeclaration = typeDeclaration;
-    if (typeAliasDeclaration.type.kind !== _typescript.SyntaxKind.UnionType) throw new Error(`Unexpected type definition - ${typeDeclaration.getText(ctx.sourceFile)}. Did you mean 'class'?`);
-    const typeAliasValue = typeAliasDeclaration.type;
-    const enumValues = getEnumValues(typeAliasValue, typeDeclaration, ctx);
-    if (typeDeclaration) return {
-      name,
-      decorators,
-      enumValues,
-      comment
-    };
+    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'?`);
   }
   throw new Error(`Unexpected type kind - "${name}"`);
 }
@@ -227,64 +240,132 @@ function parseClassMember(node, parentName, ctx) {
   return result;
 }
 function parseFieldType(ctx, parentName, fieldName, node, defaultValueDescription) {
-  let isArray;
-  let isRelation;
-  let relationDenormFields;
-  let nodeType = node?.type;
-  if (nodeType?.kind === _typescript.SyntaxKind.ArrayType) {
-    isArray = true;
-    nodeType = nodeType.elementType;
-    if (nodeType?.kind === _typescript.SyntaxKind.ParenthesizedType) {
-      nodeType = nodeType.type;
-    }
-    if (nodeType?.kind === _typescript.SyntaxKind.ArrayType) {
-      throw new Error(`Nested arrays are not supported (${parentName})`);
-    }
-  }
-  if (nodeType?.kind === _typescript.SyntaxKind.TypeReference) {
-    const nt = nodeType;
-    if (nt.typeName.getText(ctx.sourceFile) === "Relation") {
-      if (!nt.typeArguments?.length) throw new Error(`Missing type argument for Relation<>: '${parentName}'`);
-      nodeType = nt.typeArguments[0];
-      isRelation = true;
-      if (nt.typeArguments[1]) {
-        const ta = nt.typeArguments[1];
-        relationDenormFields = getRelationDenormFields(ctx, ta);
-      }
-    }
-  }
-  let type;
-  if (nodeType?.kind === _typescript.SyntaxKind.UnionType) {
-    const newTypeName = `${parentName}_${_lodash.default.upperFirst(fieldName)}`;
-    ctx.result[newTypeName] = {
-      name: newTypeName,
-      decorators: {},
-      enumValues: getEnumValues(nodeType, node, ctx)
-    };
-    type = newTypeName;
-  }
-  type = type ?? nodeType?.getText(ctx.sourceFile) ?? defaultValueDescription?.type;
-  if (!type) throw new Error(`Cannot detect property type: '${node.getText(ctx.sourceFile)}'`);
-  let isChange;
-  if (type.startsWith("Change<")) {
-    type = type.slice(7, -1);
-    if (!ctx.typesMap[type]) throw new Error(`Unexpected property type: '${type}'`);
-    isChange = true;
+  const parsedType = {
+    isArray: false,
+    isRelation: false,
+    isChange: false,
+    relationDenormFields: void 0,
+    type: void 0,
+    nodeType: node.type,
+    node
+  };
+  parseFieldTypeArray(parsedType, parentName);
+  parseFieldTypeRelation(parsedType, parentName, ctx);
+  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;
+  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}'`);
+    parsedType.isChange = true;
   } else {
-    if (!supportedPrimitiveTypes.includes(type) && !ctx.typesMap[type] && !ctx.result[type] && type !== "thisReference") {
-      throw new Error(`Unexpected property type: '${type}'`);
+    if (!supportedPrimitiveTypes.includes(parsedType.type) && !ctx.typesMap[parsedType.type] && !ctx.result[parsedType.type] && parsedType.type !== "thisReference") {
+      throw new Error(`Unexpected property type: '${parsedType.type}'`);
     }
   }
   if (defaultValueDescription && defaultValueDescription.type !== "thisReference") {
-    verifyDefaultValueType(isArray, defaultValueDescription, type, supportedPrimitiveTypes, ctx);
+    verifyDefaultValueType(parsedType.isArray, defaultValueDescription, parsedType.type, supportedPrimitiveTypes, ctx);
   }
   return {
-    isArray,
-    isRelation,
-    isChange,
-    relationDenormFields,
-    type
+    isArray: parsedType.isArray || void 0,
+    isRelation: parsedType.isRelation || void 0,
+    isChange: parsedType.isChange || void 0,
+    relationDenormFields: parsedType.relationDenormFields,
+    type: parsedType.type
+  };
+}
+function parseFieldTypeRecordEnum(parsedType, parentName, fieldName, ctx) {
+  if (parsedType.nodeType?.kind !== _typescript.SyntaxKind.TypeReference) return;
+  const nt = parsedType.nodeType;
+  if (nt.typeName.getText(ctx.sourceFile) !== "Record") return;
+  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];
+  if (!keyType) return;
+  if (!ctx.result[keyTypeName]) ctx.result[keyTypeName] = parseType(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)}`;
+  const fieldsArray = enumValues.map(v => ({
+    name: v,
+    type: valueTypeName,
+    isRequired: true
+  }));
+  ctx.result[newTypeName] = {
+    name: newTypeName,
+    decorators: {},
+    fields: _lodash.default.keyBy(fieldsArray, "name")
   };
+  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, ctx) {
+  if (parsedType.nodeType?.kind !== _typescript.SyntaxKind.TypeReference) return;
+  const nt = parsedType.nodeType;
+  if (nt.typeName.getText(ctx.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(ctx, ta);
+    }
+  }
+}
+function parseFieldTypeInlineEnum(parsedType, parentName, fieldName, ctx) {
+  if (parsedType.nodeType?.kind !== _typescript.SyntaxKind.UnionType) return;
+  const nt = parsedType.nodeType;
+  const enumValues = getEnumValues(nt, parsedType.node, ctx);
+  const newTypeName = `${parentName}_${_lodash.default.upperFirst(fieldName)}`;
+  ctx.result[newTypeName] = {
+    name: newTypeName,
+    decorators: {},
+    enumValues
+  };
+  parsedType.type = newTypeName;
+}
+function parseFieldTypeKeyofEnum(parsedType, parentName, fieldName, ctx) {
+  if (parsedType.nodeType?.kind !== _typescript.SyntaxKind.TypeOperator) return;
+  const nt = parsedType.nodeType;
+  if (nt.operator !== _typescript.SyntaxKind.KeyOfKeyword) return;
+  const enumValues = getEnumValuesFromKeyOf(nt, ctx);
+  const newTypeName = `${parentName}_${_lodash.default.upperFirst(fieldName)}`;
+  ctx.result[newTypeName] = {
+    name: newTypeName,
+    decorators: {},
+    enumValues
+  };
+  parsedType.type = newTypeName;
+}
+function getEnumValuesFromKeyOf(nodeType, ctx) {
+  if (nodeType.type.kind !== _typescript.SyntaxKind.TypeReference) {
+    throw new Error(`Unexpected type - ${nodeType.type.getText(ctx.sourceFile)}`);
+  }
+  const typeReferenceNode = nodeType.type;
+  if (typeReferenceNode.typeName.kind !== _typescript.SyntaxKind.Identifier) {
+    throw new Error(`Unexpected type - ${typeReferenceNode.getText(ctx.sourceFile)}`);
+  }
+  const typeName = typeReferenceNode.typeName.text;
+  const type = ctx.typesMap[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].fields) throw new Error(`Unexpected type - ${typeName}`);
+  return Object.keys(ctx.result[typeName].fields);
 }
 function getRelationDenormFields(ctx, node) {
   if (node.kind === _typescript.SyntaxKind.LiteralType) {
@@ -309,9 +390,11 @@ function verifyDefaultValueType(isArray, defaultValueDescription, type, supporte
     if (supportedPrimitiveTypes2.includes(type) && defaultValueDescription.type !== 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);
     const enumValues = ctx.result[type]?.enumValues;
     if (enumValues && !enumValues.includes(defaultValueDescription.value)) {
-      throw new Error(`Default value type is different from field type: '${type}'`);
+      const enumValuesStr = enumValues.map(x => `'x'`).join(", ");
+      throw new Error(`Default value must be one of: ${enumValuesStr}`);
     }
   }
 }

package/integrations/lib.mjs

@@ -99,6 +99,8 @@ function getOrder(f) {
   return decorator.order ?? defaultOrders[decorator.preset] ?? 0;
 }
 function parseType(typeDeclaration, typeName, ctx) {
+  if (ctx.result[typeName])
+    return ctx.result[typeName];
   const { modifiers } = typeDeclaration;
   const nameNode = typeDeclaration.name;
   if (!nameNode || nameNode.kind !== SyntaxKind.Identifier)
@@ -136,12 +138,17 @@ function parseType(typeDeclaration, typeName, ctx) {
   }
   if (typeDeclaration.kind === SyntaxKind.TypeAliasDeclaration) {
     const typeAliasDeclaration = typeDeclaration;
-    if (typeAliasDeclaration.type.kind !== SyntaxKind.UnionType)
-      throw new Error(`Unexpected type definition - ${typeDeclaration.getText(ctx.sourceFile)}. Did you mean 'class'?`);
-    const typeAliasValue = typeAliasDeclaration.type;
-    const enumValues = getEnumValues(typeAliasValue, typeDeclaration, ctx);
-    if (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'?`);
   }
   throw new Error(`Unexpected type kind - "${name}"`);
 }
@@ -206,61 +213,136 @@ function parseClassMember(node, parentName, ctx) {
   return result;
 }
 function parseFieldType(ctx, parentName, fieldName, node, defaultValueDescription) {
-  let isArray;
-  let isRelation;
-  let relationDenormFields;
-  let nodeType = node?.type;
-  if (nodeType?.kind === SyntaxKind.ArrayType) {
-    isArray = true;
-    nodeType = nodeType.elementType;
-    if (nodeType?.kind === SyntaxKind.ParenthesizedType) {
-      nodeType = nodeType.type;
-    }
-    if (nodeType?.kind === SyntaxKind.ArrayType) {
-      throw new Error(`Nested arrays are not supported (${parentName})`);
+  const parsedType = {
+    isArray: false,
+    isRelation: false,
+    isChange: false,
+    relationDenormFields: void 0,
+    type: void 0,
+    nodeType: node.type,
+    node
+  };
+  parseFieldTypeArray(parsedType, parentName);
+  parseFieldTypeRelation(parsedType, parentName, ctx);
+  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;
+  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}'`);
+    parsedType.isChange = true;
+  } else {
+    if (!supportedPrimitiveTypes.includes(parsedType.type) && !ctx.typesMap[parsedType.type] && !ctx.result[parsedType.type] && parsedType.type !== "thisReference") {
+      throw new Error(`Unexpected property type: '${parsedType.type}'`);
     }
   }
-  if (nodeType?.kind === SyntaxKind.TypeReference) {
-    const nt = nodeType;
-    if (nt.typeName.getText(ctx.sourceFile) === "Relation") {
-      if (!nt.typeArguments?.length)
-        throw new Error(`Missing type argument for Relation<>: '${parentName}'`);
-      nodeType = nt.typeArguments[0];
-      isRelation = true;
-      if (nt.typeArguments[1]) {
-        const ta = nt.typeArguments[1];
-        relationDenormFields = getRelationDenormFields(ctx, ta);
-      }
-    }
+  if (defaultValueDescription && defaultValueDescription.type !== "thisReference") {
+    verifyDefaultValueType(parsedType.isArray, defaultValueDescription, parsedType.type, supportedPrimitiveTypes, ctx);
   }
-  let type;
-  if (nodeType?.kind === SyntaxKind.UnionType) {
-    const newTypeName = `${parentName}_${_.upperFirst(fieldName)}`;
-    ctx.result[newTypeName] = {
-      name: newTypeName,
-      decorators: {},
-      enumValues: getEnumValues(nodeType, node, ctx)
-    };
-    type = newTypeName;
+  return {
+    isArray: parsedType.isArray || void 0,
+    isRelation: parsedType.isRelation || void 0,
+    isChange: parsedType.isChange || void 0,
+    relationDenormFields: parsedType.relationDenormFields,
+    type: parsedType.type
+  };
+}
+function parseFieldTypeRecordEnum(parsedType, parentName, fieldName, ctx) {
+  if (parsedType.nodeType?.kind !== SyntaxKind.TypeReference)
+    return;
+  const nt = parsedType.nodeType;
+  if (nt.typeName.getText(ctx.sourceFile) !== "Record")
+    return;
+  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];
+  if (!keyType)
+    return;
+  if (!ctx.result[keyTypeName])
+    ctx.result[keyTypeName] = parseType(keyType.node, keyTypeName, ctx);
+  const enumValues = ctx.result[keyTypeName].enumValues;
+  if (!enumValues)
+    throw new Error(`Unexpected type - ${keyTypeName}`);
+  const newTypeName = `${parentName}_${_.upperFirst(fieldName)}`;
+  const fieldsArray = enumValues.map((v) => ({ name: v, type: valueTypeName, isRequired: true }));
+  ctx.result[newTypeName] = {
+    name: newTypeName,
+    decorators: {},
+    fields: _.keyBy(fieldsArray, "name")
+  };
+  parsedType.type = newTypeName;
+}
+function parseFieldTypeArray(parsedType, parentName) {
+  if (parsedType.nodeType?.kind !== SyntaxKind.ArrayType)
+    return;
+  parsedType.isArray = true;
+  parsedType.nodeType = parsedType.nodeType.elementType;
+  if (parsedType.nodeType?.kind === SyntaxKind.ParenthesizedType) {
+    parsedType.nodeType = parsedType.nodeType.type;
   }
-  type = type ?? nodeType?.getText(ctx.sourceFile) ?? defaultValueDescription?.type;
-  if (!type)
-    throw new Error(`Cannot detect property type: '${node.getText(ctx.sourceFile)}'`);
-  let isChange;
-  if (type.startsWith("Change<")) {
-    type = type.slice(7, -1);
-    if (!ctx.typesMap[type])
-      throw new Error(`Unexpected property type: '${type}'`);
-    isChange = true;
-  } else {
-    if (!supportedPrimitiveTypes.includes(type) && !ctx.typesMap[type] && !ctx.result[type] && type !== "thisReference") {
-      throw new Error(`Unexpected property type: '${type}'`);
+  if (parsedType.nodeType?.kind === SyntaxKind.ArrayType) {
+    throw new Error(`Nested arrays are not supported (${parentName})`);
+  }
+}
+function parseFieldTypeRelation(parsedType, parentName, ctx) {
+  if (parsedType.nodeType?.kind !== SyntaxKind.TypeReference)
+    return;
+  const nt = parsedType.nodeType;
+  if (nt.typeName.getText(ctx.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(ctx, ta);
     }
   }
-  if (defaultValueDescription && defaultValueDescription.type !== "thisReference") {
-    verifyDefaultValueType(isArray, defaultValueDescription, type, supportedPrimitiveTypes, ctx);
+}
+function parseFieldTypeInlineEnum(parsedType, parentName, fieldName, ctx) {
+  if (parsedType.nodeType?.kind !== SyntaxKind.UnionType)
+    return;
+  const nt = parsedType.nodeType;
+  const enumValues = getEnumValues(nt, parsedType.node, ctx);
+  const newTypeName = `${parentName}_${_.upperFirst(fieldName)}`;
+  ctx.result[newTypeName] = { name: newTypeName, decorators: {}, enumValues };
+  parsedType.type = newTypeName;
+}
+function parseFieldTypeKeyofEnum(parsedType, parentName, fieldName, ctx) {
+  if (parsedType.nodeType?.kind !== SyntaxKind.TypeOperator)
+    return;
+  const nt = parsedType.nodeType;
+  if (nt.operator !== SyntaxKind.KeyOfKeyword)
+    return;
+  const enumValues = getEnumValuesFromKeyOf(nt, ctx);
+  const newTypeName = `${parentName}_${_.upperFirst(fieldName)}`;
+  ctx.result[newTypeName] = { name: newTypeName, decorators: {}, enumValues };
+  parsedType.type = newTypeName;
+}
+function getEnumValuesFromKeyOf(nodeType, ctx) {
+  if (nodeType.type.kind !== SyntaxKind.TypeReference) {
+    throw new Error(`Unexpected type - ${nodeType.type.getText(ctx.sourceFile)}`);
   }
-  return { isArray, isRelation, isChange, relationDenormFields, type };
+  const typeReferenceNode = nodeType.type;
+  if (typeReferenceNode.typeName.kind !== SyntaxKind.Identifier) {
+    throw new Error(`Unexpected type - ${typeReferenceNode.getText(ctx.sourceFile)}`);
+  }
+  const typeName = typeReferenceNode.typeName.text;
+  const type = ctx.typesMap[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].fields)
+    throw new Error(`Unexpected type - ${typeName}`);
+  return Object.keys(ctx.result[typeName].fields);
 }
 function getRelationDenormFields(ctx, node) {
   if (node.kind === SyntaxKind.LiteralType) {
@@ -285,9 +367,12 @@ function verifyDefaultValueType(isArray, defaultValueDescription, type, supporte
     if (supportedPrimitiveTypes2.includes(type) && defaultValueDescription.type !== 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);
     const enumValues = ctx.result[type]?.enumValues;
     if (enumValues && !enumValues.includes(defaultValueDescription.value)) {
-      throw new Error(`Default value type is different from field type: '${type}'`);
+      const enumValuesStr = enumValues.map((x) => `'x'`).join(", ");
+      throw new Error(`Default value must be one of: ${enumValuesStr}`);
     }
   }
 }

package/package.json

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