rads-db 3.0.4 → 3.0.7

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/integrations/node.cjs

@@ -159,10 +159,10 @@ function getWhereFieldsFor(schema, type, fieldKey) {
     return [`${name}?: ${fieldTypeName}_Where`, ...commonWhereFields];
   }
   if (isEnum) {
-    return [`${name}?: ${fieldTypeName}`, ...getWhereFieldsForString(fieldKey), ...commonWhereFields];
+    return [`${name}?: ${fieldTypeName}`, `${name}_in?: ${fieldTypeName}[]`, ...getWhereFieldsForString(fieldKey), ...commonWhereFields];
   }
   if (isPrimitive) {
-    return [`${name}?: ${fieldTypeName}`, ...getWhereFieldsForPrimitive(schema, type, fieldKey), ...commonWhereFields];
+    return [`${name}?: ${fieldTypeName}`, `${name}_in?: ${fieldTypeName}[]`, ...getWhereFieldsForPrimitive(schema, type, fieldKey), ...commonWhereFields];
   }
   throw new Error(`Unknown type: ${fieldTypeName}`);
 }

package/integrations/node.mjs

@@ -165,10 +165,20 @@ function getWhereFieldsFor(schema, type, fieldKey) {
     return [`${name}?: ${fieldTypeName}_Where`, ...commonWhereFields];
   }
   if (isEnum) {
-    return [`${name}?: ${fieldTypeName}`, ...getWhereFieldsForString(fieldKey), ...commonWhereFields];
+    return [
+      `${name}?: ${fieldTypeName}`,
+      `${name}_in?: ${fieldTypeName}[]`,
+      ...getWhereFieldsForString(fieldKey),
+      ...commonWhereFields
+    ];
   }
   if (isPrimitive) {
-    return [`${name}?: ${fieldTypeName}`, ...getWhereFieldsForPrimitive(schema, type, fieldKey), ...commonWhereFields];
+    return [
+      `${name}?: ${fieldTypeName}`,
+      `${name}_in?: ${fieldTypeName}[]`,
+      ...getWhereFieldsForPrimitive(schema, type, fieldKey),
+      ...commonWhereFields
+    ];
   }
   throw new Error(`Unknown type: ${fieldTypeName}`);
 }

package/package.json

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