@drizzle-graphql-suite/schema 0.8.2 → 0.9.0

package/package.json

@@ -1,24 +1,14 @@
 {
   "name": "@drizzle-graphql-suite/schema",
-  "version": "0.8.2",
-  "description": "GraphQL schema builder with CRUD operations, relation filtering, and hooks from Drizzle ORM",
+  "version": "0.9.0",
+  "description": "[DEPRECATED] Use @graphql-suite/schema instead. 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"
+    "url": "https://github.com/annexare/graphql-suite.git"
   },
-  "homepage": "https://github.com/annexare/drizzle-graphql-suite/tree/main/packages/schema#readme",
-  "keywords": [
-    "drizzle",
-    "graphql",
-    "schema",
-    "orm",
-    "postgresql",
-    "crud",
-    "typescript"
-  ],
+  "homepage": "https://graphql-suite.annexare.com",
   "type": "module",
   "publishConfig": {
     "access": "public"
@@ -32,10 +22,6 @@
     }
   },
   "dependencies": {
-    "graphql-parse-resolve-info": "4.14.1"
-  },
-  "peerDependencies": {
-    "drizzle-orm": ">=0.44.0",
-    "graphql": ">=16.3.0"
+    "@graphql-suite/schema": "0.9.0"
   }
 }

package/adapters/pg.d.ts

@@ -1,10 +0,0 @@
-import { type Column, type SQL, type Table } from 'drizzle-orm';
-import { type PgDatabase } from 'drizzle-orm/pg-core';
-import type { DbAdapter } from './types';
-export declare class PgAdapter implements DbAdapter {
-    readonly supportsReturning = true;
-    isTable(value: unknown): boolean;
-    executeInsert(db: PgDatabase<any, any, any>, table: Table, values: Record<string, any>[], returningColumns?: Record<string, Column>): Promise<any[]>;
-    executeUpdate(db: PgDatabase<any, any, any>, table: Table, set: Record<string, any>, where: SQL | undefined, returningColumns?: Record<string, Column>): Promise<any[]>;
-    executeDelete(db: PgDatabase<any, any, any>, table: Table, where: SQL | undefined, returningColumns?: Record<string, Column>): Promise<any[]>;
-}

package/adapters/types.d.ts

@@ -1,11 +0,0 @@
-import type { Column, SQL, Table } from 'drizzle-orm';
-import type { PgDatabase } from 'drizzle-orm/pg-core';
-export interface DbAdapter {
-    /** Identifies tables in the schema (e.g., is(value, PgTable)) */
-    isTable(value: unknown): boolean;
-    /** Whether mutations can return data (PG: yes via RETURNING, MySQL: no) */
-    readonly supportsReturning: boolean;
-    executeInsert(db: PgDatabase<any, any, any>, table: Table, values: Record<string, any>[], returningColumns?: Record<string, Column>): Promise<any[]>;
-    executeUpdate(db: PgDatabase<any, any, any>, table: Table, set: Record<string, any>, where: SQL | undefined, returningColumns?: Record<string, Column>): Promise<any[]>;
-    executeDelete(db: PgDatabase<any, any, any>, table: Table, where: SQL | undefined, returningColumns?: Record<string, Column>): Promise<any[]>;
-}

package/case-ops.d.ts

@@ -1,2 +0,0 @@
-export declare const uncapitalize: <T extends string>(input: T) => Uncapitalize<T>;
-export declare const capitalize: <T extends string>(input: T) => Capitalize<T>;

package/codegen.d.ts

@@ -1,12 +0,0 @@
-import type { GraphQLSchema } from 'graphql';
-export type CodegenOptions = {
-    drizzle?: {
-        /** Import path for Drizzle schema types (e.g. '@ir/core/db/schema') */
-        importPath: string;
-        /** Override mapping: Drizzle table name → export type name (e.g. { overrideToAsset: 'OverrideAsset' }) */
-        typeNames?: Record<string, string>;
-    };
-};
-export declare function generateSDL(schema: GraphQLSchema): string;
-export declare function generateTypes(schema: GraphQLSchema, options?: CodegenOptions): string;
-export declare function generateEntityDefs(schema: GraphQLSchema, options?: CodegenOptions): string;

package/data-mappers.d.ts

@@ -1,12 +0,0 @@
-import type { Relation } from 'drizzle-orm';
-import { type Column, type Table } from 'drizzle-orm';
-export type TableNamedRelations = {
-    relation: Relation;
-    targetTableName: string;
-};
-export declare const remapToGraphQLCore: (key: string, value: any, tableName: string, column: Column, relationMap?: Record<string, Record<string, TableNamedRelations>>) => any;
-export declare const remapToGraphQLSingleOutput: (queryOutput: Record<string, any>, tableName: string, table: Table, relationMap?: Record<string, Record<string, TableNamedRelations>>) => Record<string, any>;
-export declare const remapToGraphQLArrayOutput: (queryOutput: Record<string, any>[], tableName: string, table: Table, relationMap?: Record<string, Record<string, TableNamedRelations>>) => Record<string, any>[];
-export declare const remapFromGraphQLCore: (value: any, column: Column, columnName: string) => any;
-export declare const remapFromGraphQLSingleInput: (queryInput: Record<string, any>, table: Table) => Record<string, any>;
-export declare const remapFromGraphQLArrayInput: (queryInput: Record<string, any>[], table: Table) => Record<string, any>[];

package/graphql/scalars.d.ts

@@ -1,2 +0,0 @@
-import { GraphQLScalarType } from 'graphql';
-export declare const GraphQLJSON: GraphQLScalarType<any, unknown>;

package/graphql/type-builder.d.ts

@@ -1,7 +0,0 @@
-import type { Column } from 'drizzle-orm';
-import { GraphQLEnumType, GraphQLInputObjectType, GraphQLList, GraphQLNonNull, GraphQLObjectType, type GraphQLScalarType } from 'graphql';
-export type ConvertedColumn<TIsInput extends boolean = false> = {
-    type: GraphQLScalarType | GraphQLEnumType | GraphQLNonNull<GraphQLScalarType> | GraphQLNonNull<GraphQLEnumType> | GraphQLList<GraphQLScalarType> | GraphQLList<GraphQLNonNull<GraphQLScalarType>> | GraphQLNonNull<GraphQLList<GraphQLScalarType>> | GraphQLNonNull<GraphQLList<GraphQLNonNull<GraphQLScalarType>>> | (TIsInput extends true ? GraphQLInputObjectType | GraphQLNonNull<GraphQLInputObjectType> : GraphQLObjectType | GraphQLNonNull<GraphQLObjectType>);
-    description?: string;
-};
-export declare const drizzleColumnToGraphQLType: <TColumn extends Column, TIsInput extends boolean>(column: TColumn, columnName: string, tableName: string, forceNullable?: boolean, defaultIsNullable?: boolean, isInput?: TIsInput) => ConvertedColumn<TIsInput>;

package/permissions.d.ts

@@ -1,25 +0,0 @@
-import type { GraphQLFieldConfig } from 'graphql';
-import type { BuildSchemaConfig, PermissionConfig, TableAccess } from './types';
-export declare const readOnly: () => TableAccess;
-export declare const permissive: (id: string, tables?: Record<string, boolean | TableAccess>) => PermissionConfig;
-export declare const restricted: (id: string, tables?: Record<string, boolean | TableAccess>) => PermissionConfig;
-type MergeResult = {
-    config: BuildSchemaConfig;
-    /** Tables that need individual mutation entry points filtered after build */
-    mutationFilter: Record<string, {
-        insert: boolean;
-        update: boolean;
-        delete: boolean;
-    }>;
-};
-/**
- * Converts a PermissionConfig into BuildSchemaConfig overrides.
- * Returns the merged config + a map of tables needing post-build mutation filtering.
- */
-export declare function mergePermissionsIntoConfig(baseConfig: BuildSchemaConfig, permissions: PermissionConfig, allTableNames: string[]): MergeResult;
-/**
- * Removes disallowed mutation entry points from the mutations record.
- * Mutates and returns the same record.
- */
-export declare function postFilterMutations(mutations: Record<string, GraphQLFieldConfig<any, any>>, mutationFilter: MergeResult['mutationFilter']): void;
-export {};

package/row-security.d.ts

@@ -1,21 +0,0 @@
-import type { HooksConfig } from './types';
-type RowSecurityRule = (context: any) => Record<string, unknown>;
-/**
- * Generates a HooksConfig that injects WHERE clauses from row-level security rules.
- * Rules are applied as `before` hooks on query, querySingle, count, update, and delete operations.
- *
- * ```ts
- * const hooks = withRowSecurity({
- *   posts: (context) => ({ authorId: { eq: context.user.id } }),
- * })
- * ```
- */
-export declare function withRowSecurity(rules: Record<string, RowSecurityRule>): HooksConfig;
-/**
- * Deep-merges multiple HooksConfig objects.
- * - `before` hooks are chained: each runs sequentially, passing the modified args forward.
- * - `after` hooks are chained: each runs sequentially, passing the modified result forward.
- * - `resolve` hooks: last one wins (cannot be composed).
- */
-export declare function mergeHooks(...configs: (HooksConfig | undefined)[]): HooksConfig;
-export {};

package/schema-builder.d.ts

@@ -1,72 +0,0 @@
-import type { Column, Relation, Table, TablesRelationalConfig } from 'drizzle-orm';
-import { type SQL } from 'drizzle-orm';
-import { type PgDatabase, PgTable } from 'drizzle-orm/pg-core';
-import { GraphQLSchema } from 'graphql';
-import type { ResolveTree } from 'graphql-parse-resolve-info';
-import { type TableNamedRelations } from './data-mappers';
-import type { BuildSchemaConfig, GeneratedEntities, PermissionConfig } from './types';
-export declare class SchemaBuilder {
-    protected db: PgDatabase<any, any, any>;
-    protected tables: Record<string, PgTable>;
-    protected relationMap: Record<string, Record<string, TableNamedRelations>>;
-    protected relationalSchema: TablesRelationalConfig;
-    protected tableNamesMap: Record<string, string>;
-    private config;
-    private hooks;
-    private adapter;
-    private suffixes;
-    private limitRelationDepth;
-    private limitSelfRelationDepth;
-    private allTableNames;
-    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;
-        withPermissions: (permissions: PermissionConfig) => GraphQLSchema;
-        clearPermissionCache: (id?: string) => void;
-    };
-    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;
-    protected extractColumnFilters(column: Column, columnName: string, operators: any): SQL | undefined;
-    protected extractTableColumnFilters(table: Table, tableName: string, filters: any): SQL | undefined;
-    /** Combined filter extraction: column filters + relation filters */
-    private extractAllFilters;
-    protected extractRelationFilters(table: Table, tableName: string, relationName: string, filterValue: any): SQL | undefined;
-    protected buildExistsSubquery(parentTable: Table, targetTable: Table, relation: Relation, targetTableName: string, filterValue: any, quantifier: 'some' | 'every' | 'none'): SQL | undefined;
-    protected buildJoinCondition(parentTable: Table, _targetTable: Table, relation: Relation): SQL | undefined;
-    protected extractOrderBy(table: Table, orderArgs: any): SQL[];
-    protected extractColumns(tree: Record<string, ResolveTree>, table: Table): Record<string, true>;
-    private extractColumnsSQLFormat;
-    private getFieldsByTypeName;
-    private extractRelationsParams;
-    private extractRelationsParamsInner;
-    private executeWithHooks;
-    private executeCountQuery;
-}

package/types.d.ts

@@ -1,253 +0,0 @@
-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 TableAccess = {
-    query?: boolean;
-    insert?: boolean;
-    update?: boolean;
-    delete?: boolean;
-};
-export type PermissionConfig = {
-    id: string;
-    mode: 'permissive' | 'restricted';
-    tables?: Record<string, boolean | TableAccess>;
-};
-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[];
-};
-/**
- * Configuration for both the GraphQL schema builder (server) and the
- * type-safe client. Shared across `drizzle-graphql-suite/schema` and
- * `drizzle-graphql-suite/client` so a single config object drives both
- * the runtime schema and the inferred TypeScript types.
- *
- * @example
- * ```ts
- * const config = {
- *   mutations: true,
- *   limitRelationDepth: 5,
- *   limitSelfRelationDepth: 2,
- *   suffixes: { list: 's', single: '' },
- *   tables: { exclude: ['session', 'account'] },
- *   pruneRelations: {
- *     'asset.childAssets': false,
- *     'override.asset': 'leaf',
- *     'attribute.asset': { only: ['selectedVariant'] },
- *   },
- * } as const satisfies BuildSchemaConfig
- * ```
- */
-export type BuildSchemaConfig = {
-    /**
-     * Whether to generate GraphQL mutation operations (insert, update, delete).
-     * Set to `false` for a read-only schema.
-     * On the client side, controls whether mutation helpers are generated.
-     * @default true
-     */
-    mutations?: boolean;
-    /**
-     * Maximum depth for expanding relation fields in the generated schema
-     * and in client-side filter types (`InferEntityFilters`).
-     *
-     * - **Server**: limits how many levels of nested relations appear in
-     *   GraphQL object types. `undefined` means no limit.
-     * - **Client**: limits recursive relation filter type expansion to
-     *   prevent TS7056 on circular schemas. Capped at 5.
-     *
-     * Set to `0` to omit relations altogether.
-     *
-     * @example
-     * ```ts
-     * // Allow up to 5 levels of nesting
-     * { limitRelationDepth: 5 }
-     * ```
-     * @default 3 (server) / 1 (client filter types)
-     */
-    limitRelationDepth?: number;
-    /**
-     * Max occurrences of the same table via direct self-relations in a
-     * single type path. Only applies to relations where source and target
-     * table are identical (e.g., `asset.parent → asset`).
-     *
-     * - `1` = self-relation fields are omitted entirely
-     * - `2` = one level of self-relation expansion (the nested type has
-     *   no further self-relation fields)
-     *
-     * Cross-table cycles that revisit a table are governed by
-     * `limitRelationDepth` instead.
-     *
-     * @example
-     * ```ts
-     * // category.parent → category (expanded), but nested category
-     * // won't have parent/children fields
-     * { limitSelfRelationDepth: 2 }
-     * ```
-     * @default 1
-     */
-    limitSelfRelationDepth?: number;
-    /**
-     * Customizes the suffixes appended to auto-generated query names.
-     *
-     * Given a table named `asset`:
-     * - List query: `asset` + `list` suffix → e.g. `"assets"` or `"assetList"`
-     * - Single query: `asset` + `single` suffix → e.g. `"asset"` or `"assetSingle"`
-     *
-     * @example
-     * ```ts
-     * // "assets" / "asset" (pluralize list, no suffix for single)
-     * { suffixes: { list: 's', single: '' } }
-     *
-     * // "assetList" / "assetSingle" (explicit suffixes)
-     * { suffixes: { list: 'List', single: 'Single' } }
-     * ```
-     * @default { list: '', single: 'Single' }
-     */
-    suffixes?: {
-        list?: string;
-        single?: string;
-    };
-    /**
-     * Per-table lifecycle hooks for queries and mutations.
-     * Keys are table names as they appear in the Drizzle schema object.
-     *
-     * **Server-only** — hooks are executed during GraphQL resolution and have
-     * no effect on the client package. The client imports `BuildSchemaConfig`
-     * for type-level inference only (`limitRelationDepth`, `tables`, etc.)
-     * and ignores `hooks` entirely.
-     *
-     * @example
-     * ```ts
-     * {
-     *   hooks: {
-     *     asset: {
-     *       query: { before: (ctx) => { ... } },
-     *       insert: { after: (ctx, result) => { ... } },
-     *     },
-     *   },
-     * }
-     * ```
-     */
-    hooks?: HooksConfig;
-    /**
-     * Per-table configuration: exclude tables entirely or limit which
-     * operations are generated per table.
-     *
-     * Table names must match the keys in the Drizzle schema object.
-     *
-     * @example
-     * ```ts
-     * {
-     *   tables: {
-     *     // Remove auth tables from the GraphQL schema
-     *     exclude: ['session', 'account', 'verification'],
-     *     // Make 'auditLog' read-only
-     *     config: { auditLog: { queries: true, mutations: false } },
-     *   },
-     * }
-     * ```
-     */
-    tables?: {
-        /** Tables to completely exclude (no types, no operations, relations to them skipped). */
-        exclude?: readonly string[];
-        /** Per-table operation overrides. Tables not listed get default behavior. */
-        config?: Record<string, TableOperations>;
-    };
-    /**
-     * Fine-grained per-relation pruning rules that control how each
-     * relation expands in the generated schema.
-     *
-     * **Server-only** — pruning shapes the generated GraphQL schema.
-     * The client builds queries from the schema descriptor, which already
-     * reflects pruning (pruned relations are absent), so the client
-     * cannot generate queries for pruned fields.
-     *
-     * Keys use `tableName.relationName` format. Values:
-     * - `false` — relation field is omitted entirely from the parent type
-     * - `'leaf'` — relation expands with scalar columns only (no nested relations)
-     * - `{ only: string[] }` — relation expands with only the listed child relations
-     *
-     * @example
-     * ```ts
-     * {
-     *   pruneRelations: {
-     *     // Remove back-reference completely
-     *     'assetType.assets': false,
-     *     // Show override.asset but don't expand its relations
-     *     'override.asset': 'leaf',
-     *     // Only keep selectedVariant on attribute.asset
-     *     'attribute.asset': { only: ['selectedVariant'] },
-     *   },
-     * }
-     * ```
-     */
-    pruneRelations?: Record<string, RelationPruneRule>;
-    /**
-     * Enable debug logging for schema diagnostics (server-side only).
-     *
-     * - `true` — logs SDL byte size and type count
-     * - `{ schemaSize?: boolean; relationTree?: boolean }` — selective logging
-     *
-     * @example
-     * ```ts
-     * // Log everything
-     * { debug: true }
-     *
-     * // Only log the relation expansion tree
-     * { debug: { relationTree: true } }
-     * ```
-     */
-    debug?: boolean | {
-        schemaSize?: boolean;
-        relationTree?: boolean;
-    };
-};