@drizzle-graphql-suite/schema 0.5.0

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "@drizzle-graphql-suite/schema",
+  "version": "0.5.0",
+  "description": "GraphQL schema builder with CRUD operations, relation filtering, and hooks from Drizzle ORM",
+  "license": "MIT",
+  "author": "https://github.com/dmythro",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/annexare/drizzle-graphql-suite.git",
+    "directory": "packages/schema"
+  },
+  "homepage": "https://github.com/annexare/drizzle-graphql-suite/tree/main/packages/schema#readme",
+  "keywords": [
+    "drizzle",
+    "graphql",
+    "schema",
+    "orm",
+    "postgresql",
+    "crud",
+    "typescript"
+  ],
+  "type": "module",
+  "publishConfig": {
+    "access": "public"
+  },
+  "main": "./index.js",
+  "types": "./index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./index.d.ts",
+      "import": "./index.js"
+    }
+  },
+  "dependencies": {
+    "graphql-parse-resolve-info": "4.14.1"
+  },
+  "peerDependencies": {
+    "drizzle-orm": ">=0.44.0",
+    "graphql": ">=16.3.0"
+  }
+}

package/schema-builder.d.ts

@@ -0,0 +1,65 @@
+import { type PgDatabase } from 'drizzle-orm/pg-core';
+import { GraphQLSchema } from 'graphql';
+import type { BuildSchemaConfig, GeneratedEntities } from './types';
+export declare class SchemaBuilder {
+    private db;
+    private tables;
+    private relationMap;
+    private relationalSchema;
+    private tableNamesMap;
+    private config;
+    private hooks;
+    private adapter;
+    private suffixes;
+    private limitRelationDepth;
+    private limitSelfRelationDepth;
+    private excludedTables;
+    private tableOperations;
+    private pruneRelations;
+    private filterTypes;
+    private orderByTypes;
+    private filterValueTypes;
+    private selectFieldTypes;
+    private innerOrder;
+    constructor(db: PgDatabase<any, any, any>, config?: BuildSchemaConfig);
+    private toFieldMap;
+    buildEntities(): GeneratedEntities;
+    build(): {
+        schema: GraphQLSchema;
+        entities: GeneratedEntities;
+    };
+    private logDebugInfo;
+    private extractTables;
+    private getTable;
+    private buildRelationMap;
+    private getFilterType;
+    private getOrderByType;
+    private getFilterValues;
+    private getSelectFields;
+    private generateColumnFilterValues;
+    private generateSelectFields;
+    private generateTableTypes;
+    private buildRelationFilterFields;
+    private createQueryResolver;
+    private createSingleQueryResolver;
+    private createCountResolver;
+    private createInsertResolver;
+    private createInsertSingleResolver;
+    private createUpdateResolver;
+    private createDeleteResolver;
+    private extractColumnFilters;
+    private extractTableColumnFilters;
+    /** Combined filter extraction: column filters + relation filters */
+    private extractAllFilters;
+    private extractRelationFilters;
+    private buildExistsSubquery;
+    private buildJoinCondition;
+    private extractOrderBy;
+    private extractColumns;
+    private extractColumnsSQLFormat;
+    private getFieldsByTypeName;
+    private extractRelationsParams;
+    private extractRelationsParamsInner;
+    private executeWithHooks;
+    private executeCountQuery;
+}

package/types.d.ts

@@ -0,0 +1,117 @@
+import type { GraphQLFieldConfig, GraphQLInputObjectType, GraphQLObjectType, GraphQLResolveInfo } from 'graphql';
+export type GeneratedEntities = {
+    queries: Record<string, GraphQLFieldConfig<any, any>>;
+    mutations: Record<string, GraphQLFieldConfig<any, any>>;
+    inputs: Record<string, GraphQLInputObjectType>;
+    types: Record<string, GraphQLObjectType>;
+};
+export type OperationType = 'query' | 'querySingle' | 'count' | 'insert' | 'insertSingle' | 'update' | 'delete';
+export type HookContext = {
+    args: any;
+    context: any;
+    info: GraphQLResolveInfo;
+};
+export type BeforeHookResult = {
+    args?: any;
+    data?: any;
+};
+export type BeforeHookFn = (ctx: HookContext) => Promise<BeforeHookResult | undefined> | BeforeHookResult | undefined;
+export type AfterHookContext = {
+    result: any;
+    beforeData: any;
+    context: any;
+    info: GraphQLResolveInfo;
+};
+export type AfterHookFn = (ctx: AfterHookContext) => Promise<any> | any;
+export type ResolveHookContext = HookContext & {
+    defaultResolve: (overrideArgs?: any) => Promise<any>;
+};
+export type ResolveHookFn = (ctx: ResolveHookContext) => Promise<any> | any;
+export type OperationHooks = {
+    before?: BeforeHookFn;
+    after?: AfterHookFn;
+} | {
+    resolve: ResolveHookFn;
+};
+export type TableHookConfig = {
+    [K in OperationType]?: OperationHooks;
+};
+export type HooksConfig = {
+    [tableName: string]: TableHookConfig;
+};
+export type TableOperations = {
+    /** Generate query operations (list, single, count). @default true */
+    queries?: boolean;
+    /** Generate mutation operations (insert, insertSingle, update, delete). @default follows global `mutations` */
+    mutations?: boolean;
+};
+/**
+ * Controls how a specific relation expands in the schema.
+ * - `false`: relation field omitted entirely from parent type
+ * - `'leaf'`: relation expands with scalar columns only (no child relations)
+ * - `{ only: string[] }`: relation expands with only the listed child relation fields
+ */
+export type RelationPruneRule = false | 'leaf' | {
+    only: string[];
+};
+export type BuildSchemaConfig = {
+    /**
+     * Set to `false` to omit mutations from the schema.
+     * @default true
+     */
+    mutations?: boolean;
+    /**
+     * Limits depth of generated relation fields on queries.
+     * Non-negative integer or undefined (no limit).
+     * Set to 0 to omit relations altogether.
+     * @default 3
+     */
+    limitRelationDepth?: number;
+    /**
+     * Max occurrences of the same table via direct self-relations in a type path.
+     * - 1 = self-relation fields are omitted entirely (default)
+     * - 2 = one level of self-relation expansion (e.g., item.parent exists but
+     *   the nested item has no parent/children fields)
+     * Only applies to direct self-relations (source table === target table).
+     * Cross-table paths that revisit a table are governed by limitRelationDepth.
+     * @default 1
+     */
+    limitSelfRelationDepth?: number;
+    /**
+     * Customizes query name suffixes.
+     * @default { list: '', single: 'Single' }
+     */
+    suffixes?: {
+        list?: string;
+        single?: string;
+    };
+    /**
+     * Per-table hooks for queries and mutations.
+     * Keys are table names as they appear in the Drizzle schema.
+     */
+    hooks?: HooksConfig;
+    /**
+     * Per-table configuration: exclude tables or limit operations.
+     * Table names must match the keys in the Drizzle schema object.
+     */
+    tables?: {
+        /** Tables to completely exclude (no types, no operations, relations to them skipped). */
+        exclude?: string[];
+        /** Per-table operation overrides. Tables not listed get default behavior. */
+        config?: Record<string, TableOperations>;
+    };
+    /**
+     * Fine-grained per-relation pruning rules.
+     * Keys are `tableName.relationName` (e.g., `'asset.childAssets': false`).
+     */
+    pruneRelations?: Record<string, RelationPruneRule>;
+    /**
+     * Enable debug logging for schema diagnostics.
+     * - `true`: logs SDL byte size and type count
+     * - `{ schemaSize?: boolean; relationTree?: boolean }`: selective logging
+     */
+    debug?: boolean | {
+        schemaSize?: boolean;
+        relationTree?: boolean;
+    };
+};