drizzle-graphql-plus 0.8.19 → 0.8.21

package/index.js

@@ -2264,86 +2264,92 @@ var allowedNameChars2 = /^[a-zA-Z0-9_]+$/;
 var customScalars = /* @__PURE__ */ new Set();
 var enumDefinitions = /* @__PURE__ */ new Map();
 var requiredFieldFilters = /* @__PURE__ */ new Set();
+var foreignKeyTypes = /* @__PURE__ */ new Map();
 var columnToSDL = (column, columnName, tableName, forceNullable = false) => {
   let baseType;
   if (column.customGraphqlType) {
     baseType = column.customGraphqlType;
   } else {
-    switch (column.dataType) {
-      case "boolean":
-        baseType = "Boolean";
-        break;
-      case "json":
-        if (column.columnType === "PgGeometryObject") {
-          baseType = "PgGeometryObject";
-          customScalars.add("PgGeometryObject");
-        } else {
-          baseType = "JSON";
-          customScalars.add("JSON");
-        }
-        break;
-      case "date":
-        baseType = "Date";
-        customScalars.add("Date");
-        break;
-      case "string":
-        if (column.enumValues?.length) {
-          const enumName = `${capitalize(tableName)}${capitalize(
-            columnName
-          )}Enum`;
-          baseType = enumName;
-          if (!enumDefinitions.has(enumName)) {
-            enumDefinitions.set(enumName, {
-              name: enumName,
-              values: column.enumValues.map(
-                (e, index) => allowedNameChars2.test(e) ? e : `Option${index}`
-              )
-            });
+    const foreignKeyType = foreignKeyTypes.get(`${tableName}.${columnName}`);
+    if (foreignKeyType) {
+      baseType = foreignKeyType;
+    } else {
+      switch (column.dataType) {
+        case "boolean":
+          baseType = "Boolean";
+          break;
+        case "json":
+          if (column.columnType === "PgGeometryObject") {
+            baseType = "PgGeometryObject";
+            customScalars.add("PgGeometryObject");
+          } else {
+            baseType = "JSON";
+            customScalars.add("JSON");
           }
-        } else {
-          baseType = "String";
-        }
-        break;
-      case "bigint":
-        baseType = "BigInt";
-        customScalars.add("BigInt");
-        break;
-      case "number":
-        if (is7(column, PgInteger2) || is7(column, PgSerial2) || is7(column, MySqlInt2) || is7(column, MySqlSerial2) || is7(column, SQLiteInteger2)) {
-          baseType = "Int";
-        } else {
-          baseType = "Float";
-        }
-        break;
-      case "buffer":
-        baseType = "[Int!]";
-        break;
-      case "array":
-        if (column.columnType === "PgVector") {
-          baseType = "[Float!]";
-        } else if (column.columnType === "PgGeometry") {
-          baseType = "[Float!]";
-        } else {
-          const scalarName = `${capitalize(tableName)}${capitalize(
-            columnName
-          )}Array`;
-          baseType = scalarName;
-          customScalars.add(scalarName);
-        }
-        break;
-      case "custom":
-      default:
-        if (column.columnType) {
-          baseType = column.columnType;
-          customScalars.add(column.columnType);
-        } else {
-          const customScalarName = `${capitalize(tableName)}${capitalize(
-            columnName
-          )}`;
-          baseType = customScalarName;
-          customScalars.add(customScalarName);
-        }
-        break;
+          break;
+        case "date":
+          baseType = "Date";
+          customScalars.add("Date");
+          break;
+        case "string":
+          if (column.enumValues?.length) {
+            const enumName = `${capitalize(tableName)}${capitalize(
+              columnName
+            )}Enum`;
+            baseType = enumName;
+            if (!enumDefinitions.has(enumName)) {
+              enumDefinitions.set(enumName, {
+                name: enumName,
+                values: column.enumValues.map(
+                  (e, index) => allowedNameChars2.test(e) ? e : `Option${index}`
+                )
+              });
+            }
+          } else {
+            baseType = "String";
+          }
+          break;
+        case "bigint":
+          baseType = "BigInt";
+          customScalars.add("BigInt");
+          break;
+        case "number":
+          if (is7(column, PgInteger2) || is7(column, PgSerial2) || is7(column, MySqlInt2) || is7(column, MySqlSerial2) || is7(column, SQLiteInteger2)) {
+            baseType = "Int";
+          } else {
+            baseType = "Float";
+          }
+          break;
+        case "buffer":
+          baseType = "[Int!]";
+          break;
+        case "array":
+          if (column.columnType === "PgVector") {
+            baseType = "[Float!]";
+          } else if (column.columnType === "PgGeometry") {
+            baseType = "[Float!]";
+          } else {
+            const scalarName = `${capitalize(tableName)}${capitalize(
+              columnName
+            )}Array`;
+            baseType = scalarName;
+            customScalars.add(scalarName);
+          }
+          break;
+        case "custom":
+        default:
+          if (column.columnType) {
+            baseType = column.columnType;
+            customScalars.add(column.columnType);
+          } else {
+            const customScalarName = `${capitalize(tableName)}${capitalize(
+              columnName
+            )}`;
+            baseType = customScalarName;
+            customScalars.add(customScalarName);
+          }
+          break;
+      }
     }
   }
   if (!forceNullable && column.notNull) {
@@ -2400,6 +2406,53 @@ var generateTypeDefs = (tables, relations) => {
   customScalars.clear();
   enumDefinitions.clear();
   requiredFieldFilters.clear();
+  foreignKeyTypes.clear();
+  for (const [tableName, tableRelations] of Object.entries(relations)) {
+    const tableInfo = tables[tableName];
+    if (!tableInfo)
+      continue;
+    for (const [relationName, relationInfo] of Object.entries(tableRelations)) {
+      const relation = relationInfo.relation;
+      if (!is7(relation, One2))
+        continue;
+      const config = relation.config;
+      if (!config?.fields || !config?.references)
+        continue;
+      const referencedTableName = relationInfo.targetTableName;
+      const referencedTable = tables[referencedTableName];
+      if (!referencedTable)
+        continue;
+      for (let i = 0; i < config.fields.length; i++) {
+        const field = config.fields[i];
+        const reference = config.references[i];
+        if (!field || !reference)
+          continue;
+        const fieldColumnName = field.name;
+        const referenceColumnName = reference.name;
+        const foreignKeyColumn = Object.values(tableInfo.columns).find(
+          (col) => col.name === fieldColumnName
+        );
+        const referencedColumn = Object.values(referencedTable.columns).find(
+          (col) => col.name === referenceColumnName
+        );
+        if (!foreignKeyColumn || !referencedColumn)
+          continue;
+        const foreignKeyPropertyName = Object.keys(tableInfo.columns).find(
+          (key) => tableInfo.columns[key] === foreignKeyColumn
+        );
+        if (!foreignKeyPropertyName)
+          continue;
+        const referencedCustomType = referencedColumn.customGraphqlType;
+        const foreignKeyHasCustomType = !!foreignKeyColumn.customGraphqlType;
+        if (referencedCustomType && !foreignKeyHasCustomType) {
+          foreignKeyTypes.set(
+            `${tableName}.${foreignKeyPropertyName}`,
+            referencedCustomType
+          );
+        }
+      }
+    }
+  }
   for (const [tableName, tableInfo] of Object.entries(tables)) {
     const typeName = capitalize(tableName);
     const fields = [];
@@ -2555,7 +2608,7 @@ var generateQueryTypeDefs = (tables) => {
   for (const tableName of Object.keys(tables)) {
     const typeName = capitalize(tableName);
     queryFields.push(
-      `  ${tableName}(where: ${typeName}Filters, orderBy: ${typeName}OrderBy, limit: Int, offset: Int): [${typeName}!]!`
+      `  ${tableName}FindMany(where: ${typeName}Filters, orderBy: ${typeName}OrderBy, limit: Int, offset: Int): [${typeName}!]!`
     );
   }
   return `type Query {
@@ -2567,13 +2620,13 @@ var generateMutationTypeDefs = (tables) => {
   for (const tableName of Object.keys(tables)) {
     const typeName = capitalize(tableName);
     mutationFields.push(
-      `  insert${typeName}(values: [${typeName}InsertInput!]!): [${typeName}!]!`
+      `  ${tableName}InsertMany(values: [${typeName}InsertInput!]!): [${typeName}!]!`
     );
     mutationFields.push(
-      `  update${typeName}(where: ${typeName}Filters, set: ${typeName}UpdateInput!): [${typeName}!]!`
+      `  ${tableName}UpdateMany(where: ${typeName}Filters, set: ${typeName}UpdateInput!): [${typeName}!]!`
     );
     mutationFields.push(
-      `  delete${typeName}(where: ${typeName}Filters): [${typeName}!]!`
+      `  ${tableName}DeleteMany(where: ${typeName}Filters): [${typeName}!]!`
     );
   }
   return `type Mutation {
@@ -2801,6 +2854,41 @@ var extractRelationsParams2 = (relationMap, tables, tableName, fields) => {
   }
   return Object.keys(args).length > 0 ? args : void 0;
 };
+var createQueryResolver = (queryBase, tableInfo, tables, relations) => {
+  return async (parent, args, context, info) => {
+    try {
+      const { where, orderBy, limit, offset } = args;
+      const parsedInfo = parseResolveInfo4(info, {
+        deep: true
+      });
+      const allFields = {};
+      if (parsedInfo.fieldsByTypeName) {
+        for (const fields of Object.values(parsedInfo.fieldsByTypeName)) {
+          Object.assign(allFields, fields);
+        }
+      }
+      const result = await queryBase.findMany({
+        columns: extractSelectedColumns(allFields, tableInfo),
+        offset,
+        limit,
+        orderBy: buildOrderByClause(tableInfo, orderBy),
+        where: buildWhereClause(tableInfo, where),
+        with: extractRelationsParams2(
+          relations,
+          tables,
+          tableInfo.name,
+          allFields
+        )
+      });
+      return result;
+    } catch (e) {
+      if (typeof e === "object" && e !== null && "message" in e) {
+        throw new GraphQLError6(String(e.message));
+      }
+      throw e;
+    }
+  };
+};
 var generateQueries = (db, tables, relations) => {
   const queries = {};
   for (const [tableName, tableInfo] of Object.entries(tables)) {
@@ -2810,34 +2898,12 @@ var generateQueries = (db, tables, relations) => {
         `Drizzle-GraphQL Error: Table ${tableName} not found in drizzle instance. Did you forget to pass schema to drizzle constructor?`
       );
     }
-    queries[tableName] = async (parent, args, context, info) => {
-      try {
-        const { where, orderBy, limit, offset } = args;
-        const parsedInfo = parseResolveInfo4(info, {
-          deep: true
-        });
-        const allFields = {};
-        if (parsedInfo.fieldsByTypeName) {
-          for (const fields of Object.values(parsedInfo.fieldsByTypeName)) {
-            Object.assign(allFields, fields);
-          }
-        }
-        const result = await queryBase.findMany({
-          columns: extractSelectedColumns(allFields, tableInfo),
-          offset,
-          limit,
-          orderBy: buildOrderByClause(tableInfo, orderBy),
-          where: buildWhereClause(tableInfo, where),
-          with: extractRelationsParams2(relations, tables, tableName, allFields)
-        });
-        return result;
-      } catch (e) {
-        if (typeof e === "object" && e !== null && "message" in e) {
-          throw new GraphQLError6(String(e.message));
-        }
-        throw e;
-      }
-    };
+    queries[`${tableName}FindMany`] = createQueryResolver(
+      queryBase,
+      tableInfo,
+      tables,
+      relations
+    );
   }
   return queries;
 };
@@ -2885,11 +2951,31 @@ var buildWhereClause2 = (tableInfo, where) => {
     return conditions[0];
   return and3(...conditions);
 };
-var generateMutations = (db, tables) => {
+var generateMutations = (db, tables, relations) => {
   const mutations = {};
   for (const [tableName, tableInfo] of Object.entries(tables)) {
     const capitalizedName = capitalize(tableName);
-    mutations[`insert${capitalizedName}`] = async (parent, args, context, info) => {
+    const queryBase = db.query[tableName];
+    if (!queryBase) {
+      throw new Error(
+        `Drizzle-GraphQL Error: Table ${tableName} not found in drizzle instance. Did you forget to pass schema to drizzle constructor?`
+      );
+    }
+    const primaryKeyColumn = Object.values(tableInfo.columns).find(
+      (col) => col.primary || col.name === "id"
+    );
+    if (!primaryKeyColumn) {
+      throw new Error(
+        `Drizzle-GraphQL Error: Table ${tableName} does not have a primary key column`
+      );
+    }
+    const queryResolver = createQueryResolver(
+      queryBase,
+      tableInfo,
+      tables,
+      relations
+    );
+    mutations[`${tableName}InsertMany`] = async (parent, args, context, info) => {
       try {
         const { values } = args;
         if (!values || values.length === 0) {
@@ -2899,8 +2985,20 @@ var generateMutations = (db, tables) => {
           values,
           tableInfo.table
         );
-        const result = await db.insert(tableInfo.table).values(remappedValues).returning();
-        return result;
+        const insertedRows = await db.insert(tableInfo.table).values(remappedValues).returning();
+        const insertedIds = insertedRows.map(
+          (row) => row[primaryKeyColumn.name]
+        );
+        return queryResolver(
+          parent,
+          {
+            where: {
+              [primaryKeyColumn.name]: { inArray: insertedIds }
+            }
+          },
+          context,
+          info
+        );
       } catch (e) {
         if (typeof e === "object" && e !== null && "message" in e) {
           throw new GraphQLError7(String(e.message));
@@ -2908,7 +3006,7 @@ var generateMutations = (db, tables) => {
         throw e;
       }
     };
-    mutations[`update${capitalizedName}`] = async (parent, args, context, info) => {
+    mutations[`${tableName}UpdateMany`] = async (parent, args, context, info) => {
       try {
         const { where, set } = args;
         if (!set || Object.keys(set).length === 0) {
@@ -2920,8 +3018,20 @@ var generateMutations = (db, tables) => {
         if (whereClause) {
           query = query.where(whereClause);
         }
-        const result = await query.returning();
-        return result;
+        const updatedRows = await query.returning();
+        const updatedIds = updatedRows.map(
+          (row) => row[primaryKeyColumn.name]
+        );
+        return queryResolver(
+          parent,
+          {
+            where: {
+              [primaryKeyColumn.name]: { inArray: updatedIds }
+            }
+          },
+          context,
+          info
+        );
       } catch (e) {
         if (typeof e === "object" && e !== null && "message" in e) {
           throw new GraphQLError7(String(e.message));
@@ -2929,7 +3039,7 @@ var generateMutations = (db, tables) => {
         throw e;
       }
     };
-    mutations[`delete${capitalizedName}`] = async (parent, args, context, info) => {
+    mutations[`${tableName}DeleteMany`] = async (parent, args, context, info) => {
       try {
         const { where } = args;
         const whereClause = buildWhereClause2(tableInfo, where);
@@ -2970,7 +3080,7 @@ var buildSchemaSDL = (db, config) => {
   typeDefsArray.push(generateMutationTypeDefs(tables));
   const typeDefs = typeDefsArray.join("\n\n");
   const queries = generateQueries(db, tables, relations);
-  const mutations = generateMutations(db, tables);
+  const mutations = generateMutations(db, tables, relations);
   return {
     typeDefs,
     resolvers: {