drizzle-graphql-plus 0.8.14 → 0.8.16

package/index.js

@@ -1,4 +1,4 @@
-// src/index.ts
+// src/buildSchema.ts
 import { is as is6 } from "drizzle-orm";
 import { MySqlDatabase as MySqlDatabase2 } from "drizzle-orm/mysql-core";
 import { PgDatabase as PgDatabase2 } from "drizzle-orm/pg-core";
@@ -320,9 +320,6 @@ var extractSelectedColumnsFromTree = (tree, table) => {
         fieldData.fieldsByTypeName
       )) {
         for (const [subFieldName, subFieldData] of Object.entries(typeFields)) {
-          console.log(
-            `    Checking subField: ${subFieldName}, name: ${subFieldData.name}`
-          );
           if (tableColumns[subFieldData.name]) {
             selectedColumns.push([subFieldData.name, true]);
           } else {
@@ -2199,7 +2196,7 @@ var generateSchemaData3 = (db, schema, relationsDepthLimit) => {
   return { queries, mutations, inputs, interfaces, types: outputs };
 };
 
-// src/index.ts
+// src/buildSchema.ts
 var buildSchema = (db, config) => {
   const schema = db._.fullSchema;
   if (!schema) {
@@ -2246,7 +2243,777 @@ var buildSchema = (db, config) => {
   const outputSchema = new GraphQLSchema(graphQLSchemaConfig);
   return { schema: outputSchema, entities: generatorOutput };
 };
+
+// src/buildSchemaSDL/index.ts
+import { is as is8 } from "drizzle-orm";
+import { BaseSQLiteDatabase as BaseSQLiteDatabase3 } from "drizzle-orm/sqlite-core";
+
+// src/buildSchemaSDL/generator/schema.ts
+import {
+  getTableColumns as getTableColumns3,
+  getTableName,
+  is as is7,
+  Relations as Relations4,
+  createTableRelationsHelpers as createTableRelationsHelpers4,
+  One as One2
+} from "drizzle-orm";
+import { MySqlInt as MySqlInt2, MySqlSerial as MySqlSerial2 } from "drizzle-orm/mysql-core";
+import { PgInteger as PgInteger2, PgSerial as PgSerial2 } from "drizzle-orm/pg-core";
+import { SQLiteInteger as SQLiteInteger2 } from "drizzle-orm/sqlite-core";
+var allowedNameChars2 = /^[a-zA-Z0-9_]+$/;
+var customScalars = /* @__PURE__ */ new Set();
+var enumDefinitions = /* @__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}`
+              )
+            });
+          }
+        } 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 && !column.hasDefault && !column.defaultFn) {
+    return `${baseType}!`;
+  }
+  return baseType;
+};
+var generateTypes = (db, schema) => {
+  const tables = {};
+  const schemaEntries = Object.entries(schema);
+  const tableEntries = [];
+  for (const [key, value] of schemaEntries) {
+    if (value && typeof value === "object" && "getSQL" in value) {
+      const table = value;
+      const tableName = getTableName(table);
+      const columns = getTableColumns3(table);
+      tables[tableName] = {
+        name: tableName,
+        table,
+        columns
+      };
+      tableEntries.push([tableName, table]);
+    }
+  }
+  const rawRelations = schemaEntries.filter(([key, value]) => is7(value, Relations4)).map(([key, value]) => [
+    tableEntries.find(
+      ([tableName, tableValue]) => tableValue === value.table
+    )[0],
+    value
+  ]).map(([tableName, relValue]) => [
+    tableName,
+    relValue.config(createTableRelationsHelpers4(tables[tableName].table))
+  ]);
+  const namedRelations = Object.fromEntries(
+    rawRelations.map(([relName, config]) => {
+      const namedConfig = Object.fromEntries(
+        Object.entries(config).map(([innerRelName, innerRelValue]) => [
+          innerRelName,
+          {
+            relation: innerRelValue,
+            targetTableName: tableEntries.find(
+              ([tableName, tableValue]) => tableValue === innerRelValue.referencedTable
+            )[0]
+          }
+        ])
+      );
+      return [relName, namedConfig];
+    })
+  );
+  return { tables, relations: namedRelations };
+};
+var generateTypeDefs = (tables, relations) => {
+  const typeDefs = [];
+  customScalars.clear();
+  enumDefinitions.clear();
+  for (const [tableName, tableInfo] of Object.entries(tables)) {
+    const typeName = capitalize(tableName);
+    const fields = [];
+    for (const [columnName, column] of Object.entries(tableInfo.columns)) {
+      const typeStr = columnToSDL(
+        column,
+        columnName,
+        tableName,
+        false
+      );
+      const description = column.customGraphqlDescription;
+      if (description) {
+        fields.push(`  """${description}"""`);
+      }
+      fields.push(`  ${columnName}: ${typeStr}`);
+    }
+    const tableRelations = relations[tableName];
+    if (tableRelations) {
+      for (const [relationName, relationInfo] of Object.entries(
+        tableRelations
+      )) {
+        const isOne = is7(relationInfo.relation, One2);
+        const targetTableName = relationInfo.targetTableName;
+        const targetTypeName = capitalize(targetTableName);
+        if (isOne) {
+          fields.push(
+            `  ${relationName}(where: ${targetTypeName}Filters): ${targetTypeName}`
+          );
+        } else {
+          fields.push(
+            `  ${relationName}(where: ${targetTypeName}Filters, orderBy: ${targetTypeName}OrderBy, limit: Int, offset: Int): [${targetTypeName}!]!`
+          );
+        }
+      }
+    }
+    typeDefs.push(`type ${typeName} {
+${fields.join("\n")}
+}`);
+    const insertFields = [];
+    for (const [columnName, column] of Object.entries(tableInfo.columns)) {
+      const typeStr = columnToSDL(
+        column,
+        columnName,
+        tableName,
+        false
+      );
+      const nullableType = typeStr.endsWith("!") ? typeStr.slice(0, -1) : typeStr;
+      insertFields.push(`  ${columnName}: ${nullableType}`);
+    }
+    if (insertFields.length > 0) {
+      typeDefs.push(
+        `input ${typeName}InsertInput {
+${insertFields.join("\n")}
+}`
+      );
+    }
+    const updateFields = [];
+    for (const [columnName, column] of Object.entries(tableInfo.columns)) {
+      const typeStr = columnToSDL(
+        column,
+        columnName,
+        tableName,
+        true
+      );
+      updateFields.push(`  ${columnName}: ${typeStr}`);
+    }
+    typeDefs.push(
+      `input ${typeName}UpdateInput {
+${updateFields.join("\n")}
+}`
+    );
+    for (const [columnName, column] of Object.entries(tableInfo.columns)) {
+      const typeStr = columnToSDL(
+        column,
+        columnName,
+        tableName,
+        true
+      );
+      const filterName = `${typeName}${capitalize(columnName)}Filters`;
+      const filterFields = [];
+      filterFields.push(`  eq: ${typeStr}`);
+      filterFields.push(`  ne: ${typeStr}`);
+      filterFields.push(`  lt: ${typeStr}`);
+      filterFields.push(`  lte: ${typeStr}`);
+      filterFields.push(`  gt: ${typeStr}`);
+      filterFields.push(`  gte: ${typeStr}`);
+      filterFields.push(`  like: String`);
+      filterFields.push(`  notLike: String`);
+      filterFields.push(`  ilike: String`);
+      filterFields.push(`  notIlike: String`);
+      filterFields.push(`  inArray: [${typeStr}!]`);
+      filterFields.push(`  notInArray: [${typeStr}!]`);
+      filterFields.push(`  isNull: Boolean`);
+      filterFields.push(`  isNotNull: Boolean`);
+      const orFilterName = `${typeName}${capitalize(columnName)}FiltersOr`;
+      typeDefs.push(`input ${orFilterName} {
+${filterFields.join("\n")}
+}`);
+      filterFields.push(`  OR: [${orFilterName}!]`);
+      typeDefs.push(`input ${filterName} {
+${filterFields.join("\n")}
+}`);
+    }
+    const whereFields = [];
+    for (const columnName of Object.keys(tableInfo.columns)) {
+      const filterName = `${typeName}${capitalize(columnName)}Filters`;
+      whereFields.push(`  ${columnName}: ${filterName}`);
+    }
+    whereFields.push(`  OR: [${typeName}FiltersOr!]`);
+    const filtersOrFields = [];
+    for (const columnName of Object.keys(tableInfo.columns)) {
+      const filterName = `${typeName}${capitalize(columnName)}Filters`;
+      filtersOrFields.push(`  ${columnName}: ${filterName}`);
+    }
+    typeDefs.push(
+      `input ${typeName}FiltersOr {
+${filtersOrFields.join("\n")}
+}`
+    );
+    typeDefs.push(`input ${typeName}Filters {
+${whereFields.join("\n")}
+}`);
+    const orderByFields = [];
+    for (const columnName of Object.keys(tableInfo.columns)) {
+      orderByFields.push(`  ${columnName}: InnerOrder`);
+    }
+    typeDefs.push(`input ${typeName}OrderBy {
+${orderByFields.join("\n")}
+}`);
+  }
+  const allDefs = [];
+  if (customScalars.size > 0) {
+    for (const scalarName of Array.from(customScalars).sort()) {
+      allDefs.push(`scalar ${scalarName}`);
+    }
+  }
+  if (enumDefinitions.size > 0) {
+    for (const enumDef of enumDefinitions.values()) {
+      const valueStrings = enumDef.values.map((v) => `  ${v}`);
+      allDefs.push(`enum ${enumDef.name} {
+${valueStrings.join("\n")}
+}`);
+    }
+  }
+  allDefs.push(`enum OrderByDirection {
+  asc
+  desc
+}`);
+  allDefs.push(`input InnerOrder {
+  direction: OrderByDirection!
+  priority: Int!
+}`);
+  allDefs.push(...typeDefs);
+  return allDefs.join("\n\n");
+};
+var generateQueryTypeDefs = (tables) => {
+  const queryFields = [];
+  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}!]!`
+    );
+  }
+  return `type Query {
+${queryFields.join("\n")}
+}`;
+};
+var generateMutationTypeDefs = (tables) => {
+  const mutationFields = [];
+  for (const tableName of Object.keys(tables)) {
+    const typeName = capitalize(tableName);
+    mutationFields.push(
+      `  insert${typeName}(values: [${typeName}InsertInput!]!): [${typeName}!]!`
+    );
+    mutationFields.push(
+      `  update${typeName}(where: ${typeName}Filters, set: ${typeName}UpdateInput!): [${typeName}!]!`
+    );
+    mutationFields.push(
+      `  delete${typeName}(where: ${typeName}Filters): [${typeName}!]!`
+    );
+  }
+  return `type Mutation {
+${mutationFields.join("\n")}
+}`;
+};
+
+// src/buildSchemaSDL/generator/queries.ts
+import {
+  eq as eq2,
+  gt as gt2,
+  gte as gte2,
+  lt as lt2,
+  lte as lte2,
+  ne as ne2,
+  inArray as inArray2,
+  notInArray as notInArray2,
+  like as like2,
+  notLike as notLike2,
+  ilike as ilike2,
+  notIlike as notIlike2,
+  isNull as isNull2,
+  isNotNull as isNotNull2,
+  and as and2,
+  or as or2,
+  asc as asc2,
+  desc as desc2
+} from "drizzle-orm";
+import { GraphQLError as GraphQLError6 } from "graphql";
+import { parseResolveInfo as parseResolveInfo4 } from "graphql-parse-resolve-info";
+var extractFiltersColumn2 = (column, columnName, operators) => {
+  const entries = Object.entries(operators);
+  if (!entries.length)
+    return void 0;
+  if (operators.OR && operators.OR.length > 0) {
+    if (entries.length > 1) {
+      throw new GraphQLError6(
+        `WHERE ${columnName}: Cannot specify both fields and 'OR' in column operators!`
+      );
+    }
+    const variants2 = [];
+    for (const variant of operators.OR) {
+      const extracted = extractFiltersColumn2(column, columnName, variant);
+      if (extracted)
+        variants2.push(extracted);
+    }
+    return variants2.length ? variants2.length > 1 ? or2(...variants2) : variants2[0] : void 0;
+  }
+  const variants = [];
+  for (const [operatorName, operatorValue] of entries) {
+    if (operatorValue === null || operatorValue === false)
+      continue;
+    switch (operatorName) {
+      case "eq":
+      case "ne":
+      case "gt":
+      case "gte":
+      case "lt":
+      case "lte": {
+        const singleValue = remapFromGraphQLCore(
+          operatorValue,
+          column,
+          columnName
+        );
+        const opMap = { eq: eq2, ne: ne2, gt: gt2, gte: gte2, lt: lt2, lte: lte2 };
+        variants.push(opMap[operatorName](column, singleValue));
+        break;
+      }
+      case "like":
+      case "notLike":
+      case "ilike":
+      case "notIlike": {
+        const opMap = { like: like2, notLike: notLike2, ilike: ilike2, notIlike: notIlike2 };
+        variants.push(opMap[operatorName](column, operatorValue));
+        break;
+      }
+      case "inArray":
+      case "notInArray": {
+        if (!operatorValue.length) {
+          throw new GraphQLError6(
+            `WHERE ${columnName}: Unable to use operator ${operatorName} with an empty array!`
+          );
+        }
+        const arrayValue = operatorValue.map(
+          (val) => remapFromGraphQLCore(val, column, columnName)
+        );
+        const opMap = { inArray: inArray2, notInArray: notInArray2 };
+        variants.push(opMap[operatorName](column, arrayValue));
+        break;
+      }
+      case "isNull":
+      case "isNotNull": {
+        const opMap = { isNull: isNull2, isNotNull: isNotNull2 };
+        variants.push(opMap[operatorName](column));
+        break;
+      }
+    }
+  }
+  return variants.length ? variants.length > 1 ? and2(...variants) : variants[0] : void 0;
+};
+var buildWhereClause = (tableInfo, where) => {
+  if (!where || Object.keys(where).length === 0) {
+    return void 0;
+  }
+  if (where.OR && where.OR.length > 0) {
+    if (Object.keys(where).length > 1) {
+      throw new GraphQLError6(
+        `WHERE ${tableInfo.name}: Cannot specify both fields and 'OR' in table filters!`
+      );
+    }
+    const variants = [];
+    for (const variant of where.OR) {
+      const extracted = buildWhereClause(tableInfo, variant);
+      if (extracted)
+        variants.push(extracted);
+    }
+    return variants.length ? variants.length > 1 ? or2(...variants) : variants[0] : void 0;
+  }
+  const conditions = [];
+  for (const [columnName, operators] of Object.entries(where)) {
+    if (columnName === "OR")
+      continue;
+    if (!operators || Object.keys(operators).length === 0)
+      continue;
+    const column = tableInfo.columns[columnName];
+    if (!column)
+      continue;
+    const extracted = extractFiltersColumn2(
+      column,
+      columnName,
+      operators
+    );
+    if (extracted)
+      conditions.push(extracted);
+  }
+  if (conditions.length === 0)
+    return void 0;
+  if (conditions.length === 1)
+    return conditions[0];
+  return and2(...conditions);
+};
+var buildOrderByClause = (tableInfo, orderBy) => {
+  if (!orderBy || Object.keys(orderBy).length === 0) {
+    return void 0;
+  }
+  const orderEntries = Object.entries(orderBy).map(([columnName, field]) => ({
+    columnName,
+    ...field
+  }));
+  orderEntries.sort((a, b) => a.priority - b.priority);
+  const orderClauses = [];
+  for (const entry of orderEntries) {
+    const column = tableInfo.columns[entry.columnName];
+    if (column) {
+      orderClauses.push(
+        entry.direction === "desc" ? desc2(column) : asc2(column)
+      );
+    }
+  }
+  return orderClauses.length > 0 ? orderClauses : void 0;
+};
+var extractSelectedColumns = (fields, tableInfo) => {
+  const columns = {};
+  for (const fieldName of Object.keys(fields)) {
+    if (tableInfo.columns[fieldName]) {
+      columns[fieldName] = true;
+    }
+  }
+  return Object.keys(columns).length > 0 ? columns : {};
+};
+var extractRelationsParams2 = (relationMap, tables, tableName, fields) => {
+  const relations = relationMap[tableName];
+  if (!relations)
+    return void 0;
+  const args = {};
+  for (const [relName, { targetTableName, relation }] of Object.entries(
+    relations
+  )) {
+    const relationField = fields[relName];
+    if (!relationField)
+      continue;
+    const allFields = {};
+    if (relationField.fieldsByTypeName) {
+      for (const typeFields of Object.values(relationField.fieldsByTypeName)) {
+        Object.assign(allFields, typeFields);
+      }
+    }
+    const targetTable = tables[targetTableName];
+    if (!targetTable)
+      continue;
+    const thisRecord = {
+      columns: extractSelectedColumns(allFields, targetTable)
+    };
+    const relationArgs = relationField.args;
+    if (relationArgs) {
+      if (relationArgs["where"]) {
+        thisRecord.where = buildWhereClause(
+          targetTable,
+          relationArgs["where"]
+        );
+      }
+      if (relationArgs["orderBy"]) {
+        thisRecord.orderBy = buildOrderByClause(
+          targetTable,
+          relationArgs["orderBy"]
+        );
+      }
+      if (relationArgs["limit"] !== void 0) {
+        thisRecord.limit = relationArgs["limit"];
+      }
+      if (relationArgs["offset"] !== void 0) {
+        thisRecord.offset = relationArgs["offset"];
+      }
+    }
+    const nestedWith = extractRelationsParams2(
+      relationMap,
+      tables,
+      targetTableName,
+      allFields
+    );
+    if (nestedWith) {
+      thisRecord.with = nestedWith;
+    }
+    args[relName] = thisRecord;
+  }
+  return Object.keys(args).length > 0 ? args : void 0;
+};
+var generateQueries = (db, tables, relations) => {
+  const queries = {};
+  for (const [tableName, tableInfo] of Object.entries(tables)) {
+    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?`
+      );
+    }
+    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;
+      }
+    };
+  }
+  return queries;
+};
+
+// src/buildSchemaSDL/generator/mutations.ts
+import { eq as eq3, and as and3, or as or3 } from "drizzle-orm";
+import { GraphQLError as GraphQLError7 } from "graphql";
+var buildWhereClause2 = (tableInfo, where) => {
+  if (!where || Object.keys(where).length === 0) {
+    return void 0;
+  }
+  if (where.OR && where.OR.length > 0) {
+    if (Object.keys(where).length > 1) {
+      throw new GraphQLError7(
+        `WHERE ${tableInfo.name}: Cannot specify both fields and 'OR' in table filters!`
+      );
+    }
+    const variants = [];
+    for (const variant of where.OR) {
+      const extracted = buildWhereClause2(tableInfo, variant);
+      if (extracted)
+        variants.push(extracted);
+    }
+    return variants.length ? variants.length > 1 ? or3(...variants) : variants[0] : void 0;
+  }
+  const conditions = [];
+  for (const [key, value] of Object.entries(where)) {
+    if (key === "OR")
+      continue;
+    if (value === null || value === void 0)
+      continue;
+    const column = tableInfo.columns[key];
+    if (column) {
+      const filters = value;
+      if (typeof filters === "object" && filters.eq !== void 0) {
+        conditions.push(eq3(column, filters.eq));
+      } else if (typeof filters !== "object" || !Array.isArray(filters)) {
+        conditions.push(eq3(column, filters));
+      }
+    }
+  }
+  if (conditions.length === 0)
+    return void 0;
+  if (conditions.length === 1)
+    return conditions[0];
+  return and3(...conditions);
+};
+var generateMutations = (db, tables) => {
+  const mutations = {};
+  for (const [tableName, tableInfo] of Object.entries(tables)) {
+    const capitalizedName = capitalize(tableName);
+    mutations[`insert${capitalizedName}`] = async (parent, args, context, info) => {
+      try {
+        const { values } = args;
+        if (!values || values.length === 0) {
+          throw new GraphQLError7("No values provided for insert");
+        }
+        const remappedValues = remapFromGraphQLArrayInput(
+          values,
+          tableInfo.table
+        );
+        const result = await db.insert(tableInfo.table).values(remappedValues).returning();
+        return result;
+      } catch (e) {
+        if (typeof e === "object" && e !== null && "message" in e) {
+          throw new GraphQLError7(String(e.message));
+        }
+        throw e;
+      }
+    };
+    mutations[`update${capitalizedName}`] = async (parent, args, context, info) => {
+      try {
+        const { where, set } = args;
+        if (!set || Object.keys(set).length === 0) {
+          throw new GraphQLError7("No values provided for update");
+        }
+        const remappedSet = remapFromGraphQLSingleInput(set, tableInfo.table);
+        const whereClause = buildWhereClause2(tableInfo, where);
+        let query = db.update(tableInfo.table).set(remappedSet);
+        if (whereClause) {
+          query = query.where(whereClause);
+        }
+        const result = await query.returning();
+        return result;
+      } catch (e) {
+        if (typeof e === "object" && e !== null && "message" in e) {
+          throw new GraphQLError7(String(e.message));
+        }
+        throw e;
+      }
+    };
+    mutations[`delete${capitalizedName}`] = async (parent, args, context, info) => {
+      try {
+        const { where } = args;
+        const whereClause = buildWhereClause2(tableInfo, where);
+        let deleteQuery = db.delete(tableInfo.table);
+        if (whereClause) {
+          deleteQuery = deleteQuery.where(whereClause);
+        }
+        const result = await deleteQuery.returning();
+        return result;
+      } catch (e) {
+        if (typeof e === "object" && e !== null && "message" in e) {
+          throw new GraphQLError7(String(e.message));
+        }
+        throw e;
+      }
+    };
+  }
+  return mutations;
+};
+
+// src/buildSchemaSDL/index.ts
+var buildSchemaSDL = (db, config) => {
+  const schema = db._.fullSchema;
+  if (!schema) {
+    throw new Error(
+      "Drizzle-GraphQL Error: Schema not found in drizzle instance. Make sure you're using drizzle-orm v0.30.9 or above and schema is passed to drizzle constructor!"
+    );
+  }
+  if (!is8(db, BaseSQLiteDatabase3)) {
+    throw new Error(
+      "Drizzle-GraphQL Error: buildSchemaSDL currently only supports SQLite databases"
+    );
+  }
+  const { tables, relations } = generateTypes(db, schema);
+  const typeDefsArray = [];
+  typeDefsArray.push(generateTypeDefs(tables, relations));
+  typeDefsArray.push(generateQueryTypeDefs(tables));
+  typeDefsArray.push(generateMutationTypeDefs(tables));
+  const typeDefs = typeDefsArray.join("\n\n");
+  const queries = generateQueries(db, tables, relations);
+  const mutations = generateMutations(db, tables);
+  return {
+    typeDefs,
+    resolvers: {
+      Query: queries,
+      Mutation: mutations
+    }
+  };
+};
+
+// src/helpers.ts
+import { getTableName as getTableName2 } from "drizzle-orm";
+function setCustomGraphQL(table, columnConfig) {
+  for (const [columnName, config] of Object.entries(columnConfig)) {
+    const column = table[columnName];
+    if (!column) {
+      console.warn(
+        `Warning: Column "${columnName}" not found in table "${getTableName2(
+          table
+        )}"`
+      );
+      continue;
+    }
+    if (typeof config === "string") {
+      column.customGraphqlType = config;
+    } else if (config && typeof config === "object") {
+      const fieldConfig = config;
+      column.customGraphqlType = fieldConfig.type;
+      if (fieldConfig.description) {
+        column.customGraphqlDescription = fieldConfig.description;
+      }
+    }
+  }
+}
+function setCustomGraphQLTypes(table, columnTypes) {
+  setCustomGraphQL(table, columnTypes);
+}
 export {
-  buildSchema
+  buildSchema,
+  buildSchemaSDL,
+  setCustomGraphQL,
+  setCustomGraphQLTypes
 };
 //# sourceMappingURL=index.js.map