@vantreeseba/drizzle-graphql 5.1.0 → 5.2.0

package/dist/index.cjs

@@ -411,6 +411,21 @@ var geoXyInputType = new import_graphql3.GraphQLInputObjectType({
   }
 });
 var columnToGraphQLCore = (column, columnName, tableName, isInput) => {
+  const dimensions = column.dimensions;
+  if (dimensions !== void 0 && dimensions > 0) {
+    const inner = columnBaseToGraphQLCore(column, columnName, tableName, isInput);
+    const innerDesc = inner.description ?? inner.type.name;
+    let type = inner.type;
+    let description = innerDesc;
+    for (let i = 0; i < dimensions; i++) {
+      type = new import_graphql3.GraphQLList(new import_graphql3.GraphQLNonNull(type));
+      description = `Array<${description}>`;
+    }
+    return { type, description };
+  }
+  return columnBaseToGraphQLCore(column, columnName, tableName, isInput);
+};
+var columnBaseToGraphQLCore = (column, columnName, tableName, isInput) => {
   const { type: baseType, constraint } = (0, import_drizzle_orm2.extractExtendedColumnType)(column);
   switch (baseType) {
     case "boolean":
@@ -442,28 +457,10 @@ var columnToGraphQLCore = (column, columnName, tableName, isInput) => {
       if (column instanceof import_pg_core.PgDateString) {
         return isInput ? { type: import_graphql3.GraphQLString, description: "Date" } : { type: import_graphql_scalars.GraphQLDate, description: "Date" };
       }
-      {
-        const dims = column.dimensions;
-        if (dims !== void 0 && dims > 0) {
-          return {
-            type: new import_graphql3.GraphQLList(new import_graphql3.GraphQLNonNull(import_graphql3.GraphQLString)),
-            description: "Array<String>"
-          };
-        }
-      }
       return { type: import_graphql3.GraphQLString, description: "String" };
     case "bigint":
       return { type: GraphQLBigIntString, description: "BigInt" };
     case "number": {
-      const dims = column.dimensions;
-      if (dims !== void 0 && dims > 0) {
-        const baseDesc = (0, import_drizzle_orm2.is)(column, import_pg_core.PgInteger) || (0, import_drizzle_orm2.is)(column, import_pg_core.PgSerial) ? "Integer" : "Float";
-        const baseType2 = baseDesc === "Integer" ? import_graphql3.GraphQLInt : import_graphql3.GraphQLFloat;
-        return {
-          type: new import_graphql3.GraphQLList(new import_graphql3.GraphQLNonNull(baseType2)),
-          description: `Array<${baseDesc}>`
-        };
-      }
       return (0, import_drizzle_orm2.is)(column, import_pg_core.PgInteger) || (0, import_drizzle_orm2.is)(column, import_pg_core.PgSerial) || (0, import_drizzle_orm2.is)(column, import_mysql_core.MySqlInt) || (0, import_drizzle_orm2.is)(column, import_mysql_core.MySqlSerial) || (0, import_drizzle_orm2.is)(column, import_sqlite_core.SQLiteInteger) ? { type: import_graphql3.GraphQLInt, description: "Integer" } : { type: import_graphql3.GraphQLFloat, description: "Float" };
     }
     case "array": {
@@ -808,52 +805,95 @@ var innerOrder = new import_graphql4.GraphQLInputObjectType({
     }
   }
 });
-var resolveGenericFilterName = (column, columnGraphQLType) => {
+var columnDialect = (column) => {
+  const ct = column.columnType ?? "";
+  if (ct.startsWith("Pg")) {
+    return "pg";
+  }
+  if (ct.startsWith("MySql")) {
+    return "mysql";
+  }
+  if (ct.startsWith("SQLite")) {
+    return "sqlite";
+  }
+  return void 0;
+};
+var resolveGenericFilterDescriptor = (column, columnGraphQLType) => {
+  if (columnGraphQLType.type === import_graphql_scalars.GraphQLJSON) {
+    return { name: "JSON", kind: "json" };
+  }
+  if (columnGraphQLType.type instanceof import_graphql4.GraphQLList) {
+    let element = columnGraphQLType.type.ofType;
+    if (element instanceof import_graphql4.GraphQLNonNull) {
+      element = element.ofType;
+    }
+    return { name: `${element.name}Array`, kind: "array" };
+  }
   if (columnGraphQLType.type === import_graphql_scalars.GraphQLUUID) {
-    return "Id";
+    return { name: "Id", kind: "scalar" };
   }
   if (columnGraphQLType.type === import_graphql4.GraphQLBoolean) {
-    return "Boolean";
+    return { name: "Boolean", kind: "scalar" };
   }
   if (columnGraphQLType.type instanceof import_graphql4.GraphQLEnumType) {
-    return columnGraphQLType.type.name;
+    return { name: columnGraphQLType.type.name, kind: "scalar" };
   }
   if (columnGraphQLType.type === GraphQLBigIntString) {
-    return "BigInt";
+    return { name: "BigInt", kind: "scalar" };
   }
   if (columnGraphQLType.type === GraphQLDecimalString) {
-    return "Decimal";
-  }
-  if (columnGraphQLType.type instanceof import_graphql4.GraphQLList) {
-    const desc2 = columnGraphQLType.description ?? "";
-    let inner = columnGraphQLType.type.ofType;
-    if (inner instanceof import_graphql4.GraphQLNonNull) {
-      inner = inner.ofType;
-    }
-    if (desc2.includes("Integer") || inner === import_graphql4.GraphQLInt) {
-      return "IntArray";
-    }
-    if (desc2.includes("Float") || inner === import_graphql4.GraphQLFloat) {
-      return "FloatArray";
-    }
-    return "StringArray";
+    return { name: "Decimal", kind: "scalar" };
   }
   const ct = column.columnType ?? "";
   if (ct === "PgTimestamp" || ct === "PgTimestampString" || ct === "PgDate") {
-    return "DateTime";
+    return { name: "DateTime", kind: "scalar" };
   }
   if (columnGraphQLType.type === import_graphql4.GraphQLInt) {
-    return "Int";
+    return { name: "Int", kind: "scalar" };
   }
   if (columnGraphQLType.type === import_graphql4.GraphQLFloat) {
-    return "Float";
+    return { name: "Float", kind: "scalar" };
   }
-  return "String";
+  return { name: "String", kind: "scalar" };
+};
+var jsonFilterFields = (column, colType) => {
+  const dialect = columnDialect(column);
+  return {
+    eq: { type: colType, description: "JSON equality on the whole value" },
+    ne: { type: colType, description: "JSON inequality on the whole value" },
+    ...dialect === "pg" || dialect === "mysql" ? {
+      contains: {
+        type: colType,
+        description: "Value structurally contains this JSON (Postgres `@>` / MySQL JSON_CONTAINS)"
+      }
+    } : {},
+    isNull: { type: import_graphql4.GraphQLBoolean },
+    isNotNull: { type: import_graphql4.GraphQLBoolean }
+  };
+};
+var arrayFilterFields = (colType, colArr, colDesc) => {
+  let element = colType.ofType;
+  if (element instanceof import_graphql4.GraphQLNonNull) {
+    element = element.ofType;
+  }
+  const elementList = new import_graphql4.GraphQLList(new import_graphql4.GraphQLNonNull(element));
+  return {
+    eq: { type: colType, description: colDesc },
+    ne: { type: colType, description: colDesc },
+    has: { type: element, description: "Array contains this element" },
+    hasSome: { type: elementList, description: "Array contains at least one of these elements (overlap, `&&`)" },
+    hasEvery: { type: elementList, description: "Array contains every one of these elements (containment, `@>`)" },
+    isEmpty: { type: import_graphql4.GraphQLBoolean, description: "When true, matches arrays with no elements" },
+    inArray: { type: colArr, description: `Array<${colDesc}>` },
+    notInArray: { type: colArr, description: `Array<${colDesc}>` },
+    isNull: { type: import_graphql4.GraphQLBoolean },
+    isNotNull: { type: import_graphql4.GraphQLBoolean }
+  };
 };
 var FILTERS_WITHOUT_STRING_OPS = /* @__PURE__ */ new Set(["Id", "Int", "Float", "BigInt", "Decimal"]);
 var generateColumnFilterValues = (column, tableName, columnName, cacheCtx) => {
   const columnGraphQLType = drizzleColumnToGraphQLType(column, columnName, tableName, true, false, true);
-  const genericName = resolveGenericFilterName(column, columnGraphQLType);
+  const { name: genericName, kind } = resolveGenericFilterDescriptor(column, columnGraphQLType);
   const cached = cacheCtx.genericFilterCache.get(genericName);
   if (cached) {
     return cached;
@@ -862,7 +902,7 @@ var generateColumnFilterValues = (column, tableName, columnName, cacheCtx) => {
   const colDesc = columnGraphQLType.description;
   const colArr = new import_graphql4.GraphQLList(new import_graphql4.GraphQLNonNull(colType));
   const omitStringOps = FILTERS_WITHOUT_STRING_OPS.has(genericName);
-  const baseFields = {
+  const baseFields = kind === "json" ? jsonFilterFields(column, colType) : kind === "array" ? arrayFilterFields(colType, colArr, colDesc) : {
     eq: { type: colType, description: colDesc },
     ne: { type: colType, description: colDesc },
     lt: { type: colType, description: colDesc },
@@ -1435,12 +1475,28 @@ var safeLikeCondition = (column, pattern, insensitive) => {
   const isPg = (column.columnType ?? "").startsWith("Pg");
   return isPg ? import_drizzle_orm3.sql`${column} ilike ${pattern} escape ${LIKE_ESCAPE_CHAR}` : import_drizzle_orm3.sql`lower(${column}) like ${pattern.toLowerCase()} escape ${LIKE_ESCAPE_CHAR}`;
 };
+var isJsonColumn2 = (column) => (column.columnType ?? "").includes("Json");
+var jsonContains = (column, columnName, value) => {
+  const serialized = JSON.stringify(value);
+  switch (columnDialect(column)) {
+    case "pg":
+      return column.columnType === "PgJson" ? import_drizzle_orm3.sql`${column}::jsonb @> ${serialized}::jsonb` : import_drizzle_orm3.sql`${column} @> ${serialized}::jsonb`;
+    case "mysql":
+      return import_drizzle_orm3.sql`json_contains(${column}, ${serialized})`;
+    default:
+      throw new import_graphql4.GraphQLError(`WHERE ${columnName}: Operator 'contains' is not supported for this dialect!`);
+  }
+};
 var extractFiltersColumn = (column, columnName, operators) => {
   const { OR, AND, NOT, ...restOperators } = operators;
   const entries = Object.entries(restOperators);
   const singleValueOps = { eq: import_drizzle_orm3.eq, ne: import_drizzle_orm3.ne, gt: import_drizzle_orm3.gt, gte: import_drizzle_orm3.gte, lt: import_drizzle_orm3.lt, lte: import_drizzle_orm3.lte };
   const stringValueOps = { like: import_drizzle_orm3.like, notLike: import_drizzle_orm3.notLike, ilike: import_drizzle_orm3.ilike, notIlike: import_drizzle_orm3.notIlike };
   const arrayValueOps = { inArray: import_drizzle_orm3.inArray, notInArray: import_drizzle_orm3.notInArray };
+  const arrayMembershipOps = {
+    hasSome: import_drizzle_orm3.arrayOverlaps,
+    hasEvery: import_drizzle_orm3.arrayContains
+  };
   const nullableOps = { isNull: import_drizzle_orm3.isNull, isNotNull: import_drizzle_orm3.isNotNull };
   const variants = [];
   for (const [operatorName, operatorValue] of entries) {
@@ -1452,6 +1508,8 @@ var extractFiltersColumn = (column, columnName, operators) => {
       variants.push(singleValueOps[operatorName](column, singleValue));
     } else if (operatorName in stringValueOps) {
       variants.push(stringValueOps[operatorName](column, operatorValue));
+    } else if (operatorName === "contains" && isJsonColumn2(column)) {
+      variants.push(jsonContains(column, columnName, operatorValue));
     } else if (operatorName in safeLikeOps) {
       const { buildPattern, insensitive } = safeLikeOps[operatorName];
       variants.push(safeLikeCondition(column, buildPattern(operatorValue), insensitive));
@@ -1461,6 +1519,15 @@ var extractFiltersColumn = (column, columnName, operators) => {
       }
       const arrayValue = operatorValue.map((val) => remapFromGraphQLCore(val, column, columnName));
       variants.push(arrayValueOps[operatorName](column, arrayValue));
+    } else if (operatorName === "has") {
+      variants.push((0, import_drizzle_orm3.arrayContains)(column, [operatorValue]));
+    } else if (operatorName in arrayMembershipOps) {
+      if (!operatorValue.length) {
+        throw new import_graphql4.GraphQLError(`WHERE ${columnName}: Unable to use operator ${operatorName} with an empty array!`);
+      }
+      variants.push(arrayMembershipOps[operatorName](column, operatorValue));
+    } else if (operatorName === "isEmpty") {
+      variants.push(import_drizzle_orm3.sql`cardinality(${column}) = 0`);
     } else if (operatorName in nullableOps) {
       variants.push(nullableOps[operatorName](column));
     } else {