🏗️ build: remove circular dependencies for successful builds

Author: m1212e

lib/abilityBuilder.ts

@@ -4,7 +4,7 @@ import { lazy } from "./helpers/lazy";
 import { mergeFilters } from "./helpers/mergeFilters";
 import { createDistinctValuesFromSQLType } from "./helpers/sqlTypes/distinctValuesFromSQLType";
 import { tableHelper } from "./helpers/tableHelpers";
-import type { Filter } from "./runtimeFiltersPlugin/pluginTypes";
+import type { Filter } from "./runtimeFiltersPlugin/filterTypes";
 import type {
   DrizzleInstance,
   DrizzleQueryFunction,

lib/orderArg.ts lib/args/orderArg.tslib/orderArg.ts renamed to lib/args/orderArg.ts

@@ -1,16 +1,16 @@
 import { toCamelCase } from "drizzle-orm/casing";
 import { capitalize } from "es-toolkit";
-import { lazy } from "./helpers/lazy";
-import { tableHelper } from "./helpers/tableHelpers";
-import type { SchemaBuilderType } from "./schemaBuilder";
+import { lazy } from "../helpers/lazy";
+import { tableHelper } from "../helpers/tableHelpers";
 import type {
   DrizzleInstance,
   DrizzleQueryFunction,
-} from "./types/drizzleInstanceType";
+} from "../types/drizzleInstanceType";
 import type {
   CustomRumblePothosConfig,
   RumbleInput,
-} from "./types/rumbleInput";
+} from "../types/rumbleInput";
+import type { SchemaBuilderType } from "../types/schemaBuilderType";
 
 export type OrderArgImplementerType<
   UserContext extends Record<string, any>,

lib/whereArg.ts lib/args/whereArg.tslib/whereArg.ts renamed to lib/args/whereArg.ts

@@ -1,19 +1,19 @@
 import { toCamelCase } from "drizzle-orm/casing";
 import { capitalize } from "es-toolkit";
-import { type EnumImplementerType, isEnumSchema } from "./enum";
-import { mapSQLTypeToGraphQLType } from "./helpers/sqlTypes/mapSQLTypeToTSType";
-import type { PossibleSQLType } from "./helpers/sqlTypes/types";
-import { tableHelper } from "./helpers/tableHelpers";
-import type { SchemaBuilderType } from "./schemaBuilder";
+import { type EnumImplementerType, isEnumSchema } from "../enum";
+import { mapSQLTypeToGraphQLType } from "../helpers/sqlTypes/mapSQLTypeToTSType";
+import type { PossibleSQLType } from "../helpers/sqlTypes/types";
+import { tableHelper } from "../helpers/tableHelpers";
 import type {
   DrizzleInstance,
   DrizzleQueryFunction,
-} from "./types/drizzleInstanceType";
-import { RumbleError } from "./types/rumbleError";
+} from "../types/drizzleInstanceType";
+import { RumbleError } from "../types/rumbleError";
 import type {
   CustomRumblePothosConfig,
   RumbleInput,
-} from "./types/rumbleInput";
+} from "../types/rumbleInput";
+import type { SchemaBuilderType } from "../types/schemaBuilderType";
 
 // TODO: in general, several of the filter methods should be more
 // restrictive in case of explicitly allowed columns
@@ -214,219 +214,3 @@ export const createWhereArgImplementer = <
 
   return whereArgImplementer;
 };
-
-export type NumberWhereInputArgument = {
-  eq?: number;
-  ne?: number;
-  gt?: number;
-  gte?: number;
-  lt?: number;
-  lte?: number;
-  in?: number[];
-  notIn?: number[];
-  like?: string;
-  ilike?: string;
-  notLike?: string;
-  notIlike?: string;
-  isNull?: boolean;
-  isNotNull?: boolean;
-  arrayOverlaps?: number[];
-  arrayContained?: number[];
-  arrayContains?: number[];
-  AND?: NumberWhereInputArgument[];
-  OR?: NumberWhereInputArgument[];
-  NOT?: NumberWhereInputArgument;
-};
-
-export type StringWhereInputArgument = {
-  eq?: string;
-  ne?: string;
-  gt?: string;
-  gte?: string;
-  lt?: string;
-  lte?: string;
-  in?: string[];
-  notIn?: string[];
-  like?: string;
-  ilike?: string;
-  notLike?: string;
-  notIlike?: string;
-  isNull?: boolean;
-  isNotNull?: boolean;
-  arrayOverlaps?: string[];
-  arrayContained?: string[];
-  arrayContains?: string[];
-  AND?: StringWhereInputArgument[];
-  OR?: StringWhereInputArgument[];
-  NOT?: StringWhereInputArgument;
-};
-
-export type DateWhereInputArgument = {
-  eq?: Date;
-  ne?: Date;
-  gt?: Date;
-  gte?: Date;
-  lt?: Date;
-  lte?: Date;
-  in?: Date[];
-  notIn?: Date[];
-  like?: string;
-  ilike?: string;
-  notLike?: string;
-  notIlike?: string;
-  isNull?: boolean;
-  isNotNull?: boolean;
-  arrayOverlaps?: Date[];
-  arrayContained?: Date[];
-  arrayContains?: Date[];
-  AND?: DateWhereInputArgument[];
-  OR?: DateWhereInputArgument[];
-  NOT?: DateWhereInputArgument;
-};
-
-export function implementDefaultWhereInputArgs<
-  UserContext extends Record<string, any>,
-  DB extends DrizzleInstance,
-  RequestEvent extends Record<string, any>,
-  Action extends string,
-  PothosConfig extends CustomRumblePothosConfig,
-  T extends SchemaBuilderType<
-    UserContext,
-    DB,
-    RequestEvent,
-    Action,
-    PothosConfig
-  >,
->(schemaBuilder: T) {
-  const IntWhereInputArgument = schemaBuilder
-    .inputRef<NumberWhereInputArgument>("IntWhereInputArgument")
-    .implement({
-      fields: (t) => ({
-        eq: t.int(),
-        ne: t.int(),
-        gt: t.int(),
-        gte: t.int(),
-        lt: t.int(),
-        lte: t.int(),
-        in: t.intList(),
-        notIn: t.intList(),
-        like: t.string(),
-        ilike: t.string(),
-        notLike: t.string(),
-        notIlike: t.string(),
-        isNull: t.boolean(),
-        isNotNull: t.boolean(),
-        arrayOverlaps: t.intList(),
-        arrayContained: t.intList(),
-        arrayContains: t.intList(),
-        AND: t.field({
-          type: [IntWhereInputArgument],
-        }),
-        OR: t.field({
-          type: [IntWhereInputArgument],
-        }),
-        NOT: t.field({
-          type: IntWhereInputArgument,
-        }),
-      }),
-    });
-
-  const FloatWhereInputArgument = schemaBuilder
-    .inputRef<NumberWhereInputArgument>("FloatWhereInputArgument")
-    .implement({
-      fields: (t) => ({
-        eq: t.float(),
-        ne: t.float(),
-        gt: t.float(),
-        gte: t.float(),
-        lt: t.float(),
-        lte: t.float(),
-        in: t.floatList(),
-        notIn: t.floatList(),
-        like: t.string(),
-        ilike: t.string(),
-        notLike: t.string(),
-        notIlike: t.string(),
-        isNull: t.boolean(),
-        isNotNull: t.boolean(),
-        arrayOverlaps: t.floatList(),
-        arrayContained: t.floatList(),
-        arrayContains: t.floatList(),
-        AND: t.field({
-          type: [FloatWhereInputArgument],
-        }),
-        OR: t.field({
-          type: [FloatWhereInputArgument],
-        }),
-        NOT: t.field({
-          type: FloatWhereInputArgument,
-        }),
-      }),
-    });
-
-  const StringWhereInputArgument = schemaBuilder
-    .inputRef<StringWhereInputArgument>("StringWhereInputArgument")
-    .implement({
-      fields: (t) => ({
-        eq: t.string(),
-        ne: t.string(),
-        gt: t.string(),
-        gte: t.string(),
-        lt: t.string(),
-        lte: t.string(),
-        in: t.stringList(),
-        notIn: t.stringList(),
-        like: t.string(),
-        ilike: t.string(),
-        notLike: t.string(),
-        notIlike: t.string(),
-        isNull: t.boolean(),
-        isNotNull: t.boolean(),
-        arrayOverlaps: t.stringList(),
-        arrayContained: t.stringList(),
-        arrayContains: t.stringList(),
-        AND: t.field({
-          type: [StringWhereInputArgument],
-        }),
-        OR: t.field({
-          type: [StringWhereInputArgument],
-        }),
-        NOT: t.field({
-          type: StringWhereInputArgument,
-        }),
-      }),
-    });
-
-  const DateWhereInputArgument = schemaBuilder
-    .inputRef<DateWhereInputArgument>("DateWhereInputArgument")
-    .implement({
-      fields: (t) => ({
-        eq: t.field({ type: "Date" }),
-        ne: t.field({ type: "Date" }),
-        gt: t.field({ type: "Date" }),
-        gte: t.field({ type: "Date" }),
-        lt: t.field({ type: "Date" }),
-        lte: t.field({ type: "Date" }),
-        in: t.field({ type: ["Date"] }),
-        notIn: t.field({ type: ["Date"] }),
-        like: t.string(),
-        ilike: t.string(),
-        notLike: t.string(),
-        notIlike: t.string(),
-        isNull: t.boolean(),
-        isNotNull: t.boolean(),
-        arrayOverlaps: t.field({ type: ["Date"] }),
-        arrayContained: t.field({ type: ["Date"] }),
-        arrayContains: t.field({ type: ["Date"] }),
-        AND: t.field({
-          type: [DateWhereInputArgument],
-        }),
-        OR: t.field({
-          type: [DateWhereInputArgument],
-        }),
-        NOT: t.field({
-          type: DateWhereInputArgument,
-        }),
-      }),
-    });
-}