drizzle-graphql-suite 0.5.0

package/packages/client/dist/index.js

@@ -0,0 +1,439 @@
+// src/query-builder.ts
+var capitalize = (s) => s.charAt(0).toUpperCase() + s.slice(1);
+function buildSelectionSet(select, schema, entityDef, indent = 4) {
+  const pad = " ".repeat(indent);
+  const lines = [];
+  for (const [key, value] of Object.entries(select)) {
+    if (value === true) {
+      lines.push(`${pad}${key}`);
+      continue;
+    }
+    if (typeof value === "object" && value !== null) {
+      const rel = entityDef.relations[key];
+      if (!rel)
+        continue;
+      const targetDef = schema[rel.entity];
+      if (!targetDef)
+        continue;
+      const inner = buildSelectionSet(value, schema, targetDef, indent + 2);
+      lines.push(`${pad}${key} {`);
+      lines.push(inner);
+      lines.push(`${pad}}`);
+    }
+  }
+  return lines.join(`
+`);
+}
+function getFilterTypeName(entityName) {
+  return `${capitalize(entityName)}Filters`;
+}
+function getOrderByTypeName(entityName) {
+  return `${capitalize(entityName)}OrderBy`;
+}
+function getInsertInputTypeName(entityName) {
+  return `${capitalize(entityName)}InsertInput`;
+}
+function getUpdateInputTypeName(entityName) {
+  return `${capitalize(entityName)}UpdateInput`;
+}
+function buildListQuery(entityName, entityDef, schema, select, hasWhere, hasOrderBy, hasLimit, hasOffset) {
+  const opName = entityDef.queryListName;
+  if (!opName)
+    throw new Error(`Entity '${entityName}' has no list query`);
+  const filterType = getFilterTypeName(entityName);
+  const orderByType = getOrderByTypeName(entityName);
+  const operationName = `${capitalize(opName)}Query`;
+  const varDefs = [];
+  const argPairs = [];
+  if (hasWhere) {
+    varDefs.push(`$where: ${filterType}`);
+    argPairs.push("where: $where");
+  }
+  if (hasOrderBy) {
+    varDefs.push(`$orderBy: ${orderByType}`);
+    argPairs.push("orderBy: $orderBy");
+  }
+  if (hasLimit) {
+    varDefs.push("$limit: Int");
+    argPairs.push("limit: $limit");
+  }
+  if (hasOffset) {
+    varDefs.push("$offset: Int");
+    argPairs.push("offset: $offset");
+  }
+  const varDefsStr = varDefs.length ? `(${varDefs.join(", ")})` : "";
+  const argsStr = argPairs.length ? `(${argPairs.join(", ")})` : "";
+  const selection = buildSelectionSet(select, schema, entityDef);
+  const query = `query ${operationName}${varDefsStr} {
+  ${opName}${argsStr} {
+${selection}
+  }
+}`;
+  return { query, variables: {}, operationName };
+}
+function buildSingleQuery(entityName, entityDef, schema, select, hasWhere, hasOrderBy, hasOffset) {
+  const opName = entityDef.queryName;
+  if (!opName)
+    throw new Error(`Entity '${entityName}' has no single query`);
+  const filterType = getFilterTypeName(entityName);
+  const orderByType = getOrderByTypeName(entityName);
+  const operationName = `${capitalize(opName)}SingleQuery`;
+  const varDefs = [];
+  const argPairs = [];
+  if (hasWhere) {
+    varDefs.push(`$where: ${filterType}`);
+    argPairs.push("where: $where");
+  }
+  if (hasOrderBy) {
+    varDefs.push(`$orderBy: ${orderByType}`);
+    argPairs.push("orderBy: $orderBy");
+  }
+  if (hasOffset) {
+    varDefs.push("$offset: Int");
+    argPairs.push("offset: $offset");
+  }
+  const varDefsStr = varDefs.length ? `(${varDefs.join(", ")})` : "";
+  const argsStr = argPairs.length ? `(${argPairs.join(", ")})` : "";
+  const selection = buildSelectionSet(select, schema, entityDef);
+  const query = `query ${operationName}${varDefsStr} {
+  ${opName}${argsStr} {
+${selection}
+  }
+}`;
+  return { query, variables: {}, operationName };
+}
+function buildCountQuery(entityName, entityDef, hasWhere) {
+  const opName = entityDef.countName;
+  if (!opName)
+    throw new Error(`Entity '${entityName}' has no count query`);
+  const filterType = getFilterTypeName(entityName);
+  const operationName = `${capitalize(opName)}Query`;
+  const varDefs = [];
+  const argPairs = [];
+  if (hasWhere) {
+    varDefs.push(`$where: ${filterType}`);
+    argPairs.push("where: $where");
+  }
+  const varDefsStr = varDefs.length ? `(${varDefs.join(", ")})` : "";
+  const argsStr = argPairs.length ? `(${argPairs.join(", ")})` : "";
+  const query = `query ${operationName}${varDefsStr} {
+  ${opName}${argsStr}
+}`;
+  return { query, variables: {}, operationName };
+}
+function buildInsertMutation(entityName, entityDef, schema, returning, isSingle) {
+  const opName = isSingle ? entityDef.insertSingleName : entityDef.insertName;
+  if (!opName)
+    throw new Error(`Entity '${entityName}' has no ${isSingle ? "insertSingle" : "insert"} mutation`);
+  const inputType = getInsertInputTypeName(entityName);
+  const operationName = `${capitalize(opName)}Mutation`;
+  const valuesType = isSingle ? `${inputType}!` : `[${inputType}!]!`;
+  const varDefs = `($values: ${valuesType})`;
+  const argsStr = "(values: $values)";
+  let selectionBlock = "";
+  if (returning) {
+    const selection = buildSelectionSet(returning, schema, entityDef);
+    selectionBlock = ` {
+${selection}
+  }`;
+  }
+  const query = `mutation ${operationName}${varDefs} {
+  ${opName}${argsStr}${selectionBlock}
+}`;
+  return { query, variables: {}, operationName };
+}
+function buildUpdateMutation(entityName, entityDef, schema, returning, hasWhere) {
+  const opName = entityDef.updateName;
+  if (!opName)
+    throw new Error(`Entity '${entityName}' has no update mutation`);
+  const updateType = getUpdateInputTypeName(entityName);
+  const filterType = getFilterTypeName(entityName);
+  const operationName = `${capitalize(opName)}Mutation`;
+  const varDefs = [`$set: ${updateType}!`];
+  const argPairs = ["set: $set"];
+  if (hasWhere) {
+    varDefs.push(`$where: ${filterType}`);
+    argPairs.push("where: $where");
+  }
+  const varDefsStr = `(${varDefs.join(", ")})`;
+  const argsStr = `(${argPairs.join(", ")})`;
+  let selectionBlock = "";
+  if (returning) {
+    const selection = buildSelectionSet(returning, schema, entityDef);
+    selectionBlock = ` {
+${selection}
+  }`;
+  }
+  const query = `mutation ${operationName}${varDefsStr} {
+  ${opName}${argsStr}${selectionBlock}
+}`;
+  return { query, variables: {}, operationName };
+}
+function buildDeleteMutation(entityName, entityDef, schema, returning, hasWhere) {
+  const opName = entityDef.deleteName;
+  if (!opName)
+    throw new Error(`Entity '${entityName}' has no delete mutation`);
+  const filterType = getFilterTypeName(entityName);
+  const operationName = `${capitalize(opName)}Mutation`;
+  const varDefs = [];
+  const argPairs = [];
+  if (hasWhere) {
+    varDefs.push(`$where: ${filterType}`);
+    argPairs.push("where: $where");
+  }
+  const varDefsStr = varDefs.length ? `(${varDefs.join(", ")})` : "";
+  const argsStr = argPairs.length ? `(${argPairs.join(", ")})` : "";
+  let selectionBlock = "";
+  if (returning) {
+    const selection = buildSelectionSet(returning, schema, entityDef);
+    selectionBlock = ` {
+${selection}
+  }`;
+  }
+  const query = `mutation ${operationName}${varDefsStr} {
+  ${opName}${argsStr}${selectionBlock}
+}`;
+  return { query, variables: {}, operationName };
+}
+
+// src/entity.ts
+function createEntityClient(entityName, entityDef, schema, executeGraphQL) {
+  return {
+    async query(params) {
+      const { select, where, limit, offset, orderBy } = params;
+      const built = buildListQuery(entityName, entityDef, schema, select, where != null, orderBy != null, limit != null, offset != null);
+      const variables = {};
+      if (where != null)
+        variables.where = where;
+      if (orderBy != null)
+        variables.orderBy = orderBy;
+      if (limit != null)
+        variables.limit = limit;
+      if (offset != null)
+        variables.offset = offset;
+      const data = await executeGraphQL(built.query, variables);
+      return data[entityDef.queryListName];
+    },
+    async querySingle(params) {
+      const { select, where, offset, orderBy } = params;
+      const built = buildSingleQuery(entityName, entityDef, schema, select, where != null, orderBy != null, offset != null);
+      const variables = {};
+      if (where != null)
+        variables.where = where;
+      if (orderBy != null)
+        variables.orderBy = orderBy;
+      if (offset != null)
+        variables.offset = offset;
+      const data = await executeGraphQL(built.query, variables);
+      return data[entityDef.queryName] ?? null;
+    },
+    async count(params) {
+      const where = params?.where;
+      const built = buildCountQuery(entityName, entityDef, where != null);
+      const variables = {};
+      if (where != null)
+        variables.where = where;
+      const data = await executeGraphQL(built.query, variables);
+      return data[entityDef.countName];
+    },
+    async insert(params) {
+      const { values, returning } = params;
+      const built = buildInsertMutation(entityName, entityDef, schema, returning, false);
+      const variables = { values };
+      const data = await executeGraphQL(built.query, variables);
+      return data[entityDef.insertName];
+    },
+    async insertSingle(params) {
+      const { values, returning } = params;
+      const built = buildInsertMutation(entityName, entityDef, schema, returning, true);
+      const variables = { values };
+      const data = await executeGraphQL(built.query, variables);
+      return data[entityDef.insertSingleName] ?? null;
+    },
+    async update(params) {
+      const { set, where, returning } = params;
+      const built = buildUpdateMutation(entityName, entityDef, schema, returning, where != null);
+      const variables = { set };
+      if (where != null)
+        variables.where = where;
+      const data = await executeGraphQL(built.query, variables);
+      return data[entityDef.updateName];
+    },
+    async delete(params) {
+      const { where, returning } = params;
+      const built = buildDeleteMutation(entityName, entityDef, schema, returning, where != null);
+      const variables = {};
+      if (where != null)
+        variables.where = where;
+      const data = await executeGraphQL(built.query, variables);
+      return data[entityDef.deleteName];
+    }
+  };
+}
+
+// src/errors.ts
+class GraphQLClientError extends Error {
+  errors;
+  status;
+  constructor(errors, status = 200) {
+    const message = errors.map((e) => e.message).join("; ");
+    super(message);
+    this.name = "GraphQLClientError";
+    this.errors = errors;
+    this.status = status;
+  }
+}
+
+class NetworkError extends Error {
+  status;
+  constructor(message, status) {
+    super(message);
+    this.name = "NetworkError";
+    this.status = status;
+  }
+}
+
+// src/schema-builder.ts
+import { getTableColumns, getTableName, is, Many, One, Relations, Table } from "drizzle-orm";
+var capitalize2 = (s) => s.charAt(0).toUpperCase() + s.slice(1);
+function buildSchemaDescriptor(schema, config = {}) {
+  const excludeSet = new Set(config.tables?.exclude ?? []);
+  const listSuffix = config.suffixes?.list ?? "s";
+  const tableMap = new Map;
+  const dbNameToKey = new Map;
+  for (const [key, value] of Object.entries(schema)) {
+    if (is(value, Table)) {
+      if (excludeSet.has(key))
+        continue;
+      const dbName = getTableName(value);
+      const cols = Object.keys(getTableColumns(value));
+      tableMap.set(key, { table: value, dbName, columns: cols });
+      dbNameToKey.set(dbName, key);
+    }
+  }
+  const relationsMap = new Map;
+  for (const value of Object.values(schema)) {
+    if (!is(value, Relations))
+      continue;
+    const sourceDbName = getTableName(value.table);
+    const sourceKey = dbNameToKey.get(sourceDbName);
+    if (!sourceKey || !tableMap.has(sourceKey))
+      continue;
+    const helpers = {
+      one: (referencedTable, cfg) => {
+        return new One(value.table, referencedTable, cfg, false);
+      },
+      many: (referencedTable, cfg) => {
+        return new Many(value.table, referencedTable, cfg);
+      }
+    };
+    const relConfig = value.config(helpers);
+    const rels = {};
+    for (const [relName, relValue] of Object.entries(relConfig)) {
+      const rel = relValue;
+      const targetDbName = rel.referencedTableName;
+      if (!targetDbName)
+        continue;
+      const targetKey = dbNameToKey.get(targetDbName);
+      if (!targetKey)
+        continue;
+      const type = is(rel, One) ? "one" : "many";
+      rels[relName] = { entity: targetKey, type };
+    }
+    relationsMap.set(sourceKey, rels);
+  }
+  const pruneRelations = config.pruneRelations ?? {};
+  for (const [sourceKey, rels] of relationsMap) {
+    for (const relName of Object.keys(rels)) {
+      const pruneKey = `${sourceKey}.${relName}`;
+      const pruneValue = pruneRelations[pruneKey];
+      if (pruneValue === false) {
+        delete rels[relName];
+      }
+    }
+  }
+  const descriptor = {};
+  for (const [key, { columns }] of tableMap) {
+    const rels = relationsMap.get(key) ?? {};
+    descriptor[key] = {
+      queryName: key,
+      queryListName: `${key}${listSuffix}`,
+      countName: `${key}Count`,
+      insertName: `insertInto${capitalize2(key)}`,
+      insertSingleName: `insertInto${capitalize2(key)}Single`,
+      updateName: `update${capitalize2(key)}`,
+      deleteName: `deleteFrom${capitalize2(key)}`,
+      fields: columns,
+      relations: rels
+    };
+  }
+  return descriptor;
+}
+
+// src/client.ts
+class GraphQLClient {
+  url;
+  schema;
+  headers;
+  constructor(config) {
+    this.url = config.url;
+    this.schema = config.schema;
+    this.headers = config.headers;
+  }
+  entity(entityName) {
+    const entityDef = this.schema[entityName];
+    if (!entityDef) {
+      throw new Error(`Entity '${entityName}' not found in schema`);
+    }
+    return createEntityClient(entityName, entityDef, this.schema, (query, variables) => this.execute(query, variables));
+  }
+  async execute(query, variables = {}) {
+    const url = typeof this.url === "function" ? this.url() : this.url;
+    const headers = {
+      "Content-Type": "application/json",
+      ...typeof this.headers === "function" ? await this.headers() : this.headers ?? {}
+    };
+    let response;
+    try {
+      response = await fetch(url, {
+        method: "POST",
+        headers,
+        body: JSON.stringify({ query, variables })
+      });
+    } catch (e) {
+      throw new NetworkError(e instanceof Error ? e.message : "Network request failed", 0);
+    }
+    if (!response.ok) {
+      throw new NetworkError(`HTTP ${response.status}: ${response.statusText}`, response.status);
+    }
+    const json = await response.json();
+    if (json.errors?.length) {
+      throw new GraphQLClientError(json.errors, response.status);
+    }
+    if (!json.data) {
+      throw new GraphQLClientError([{ message: "No data in response" }], response.status);
+    }
+    return json.data;
+  }
+}
+function createDrizzleClient(options) {
+  const schema = buildSchemaDescriptor(options.schema, options.config);
+  return new GraphQLClient({
+    url: options.url,
+    schema,
+    headers: options.headers
+  });
+}
+
+// src/index.ts
+function createClient(config) {
+  return new GraphQLClient(config);
+}
+export {
+  createDrizzleClient,
+  createClient,
+  buildSchemaDescriptor,
+  NetworkError,
+  GraphQLClientError,
+  GraphQLClient
+};

package/packages/client/dist/infer.d.ts

@@ -0,0 +1,86 @@
+import type { Many, One, Relations, Table } from 'drizzle-orm';
+type ToWire<T> = T extends Date ? string : T;
+type WireFormat<T> = {
+    [K in keyof T]: ToWire<T[K]>;
+};
+type ExtractTables<TSchema> = {
+    [K in keyof TSchema as TSchema[K] extends Table ? K : never]: TSchema[K];
+};
+type FindRelationConfig<TSchema, TTableName extends string> = {
+    [K in keyof TSchema]: TSchema[K] extends Relations<TTableName, infer TConfig> ? TConfig : never;
+}[keyof TSchema];
+type MapRelation<T> = T extends One<infer N, infer _TNullable> ? {
+    entity: N;
+    type: 'one';
+} : T extends Many<infer N> ? {
+    entity: N;
+    type: 'many';
+} : never;
+type InferRelationDefs<TSchema, TTableName extends string> = {
+    [K in keyof FindRelationConfig<TSchema, TTableName>]: MapRelation<FindRelationConfig<TSchema, TTableName>[K]>;
+};
+type ScalarFilterOps<T> = {
+    eq?: T | null;
+    ne?: T | null;
+    lt?: T | null;
+    lte?: T | null;
+    gt?: T | null;
+    gte?: T | null;
+    like?: string | null;
+    notLike?: string | null;
+    ilike?: string | null;
+    notIlike?: string | null;
+    inArray?: T[] | null;
+    notInArray?: T[] | null;
+    isNull?: boolean | null;
+    isNotNull?: boolean | null;
+};
+type InferFilters<TFields> = {
+    [K in keyof TFields]?: ScalarFilterOps<NonNullable<TFields[K]>>;
+} & {
+    OR?: InferFilters<TFields>[];
+};
+type InferInsertInput<T> = T extends Table ? WireFormat<T['$inferInsert']> : never;
+type InferUpdateInput<T> = T extends Table ? {
+    [K in keyof T['$inferInsert']]?: ToWire<T['$inferInsert'][K]> | null;
+} : never;
+type InferOrderBy<T> = T extends Table ? {
+    [K in keyof T['$inferSelect']]?: {
+        direction: 'asc' | 'desc';
+        priority: number;
+    };
+} : never;
+type ExcludedNames<TConfig> = TConfig extends {
+    tables: {
+        exclude: readonly (infer T)[];
+    };
+} ? T : never;
+type TableDbName<T> = T extends Table<infer TConfig> ? TConfig['name'] extends string ? TConfig['name'] : string : string;
+type DbNameToKey<TSchema> = {
+    [K in keyof ExtractTables<TSchema>]: TableDbName<ExtractTables<TSchema>[K]>;
+};
+type KeyForDbName<TSchema, TDbName extends string> = {
+    [K in keyof DbNameToKey<TSchema>]: DbNameToKey<TSchema>[K] extends TDbName ? K : never;
+}[keyof DbNameToKey<TSchema>];
+type ResolveRelationEntity<TSchema, TDbName extends string> = KeyForDbName<TSchema, TDbName> extends infer K ? (K extends string ? K : TDbName) : TDbName;
+type ResolveRelationDefs<TSchema, TRels> = {
+    [K in keyof TRels]: TRels[K] extends {
+        entity: infer E;
+        type: infer T;
+    } ? E extends string ? {
+        entity: ResolveRelationEntity<TSchema, E>;
+        type: T;
+    } : TRels[K] : TRels[K];
+};
+type BuildEntityDef<TSchema, T> = T extends Table ? {
+    fields: WireFormat<T['$inferSelect']>;
+    relations: ResolveRelationDefs<TSchema, InferRelationDefs<TSchema, TableDbName<T>>>;
+    filters: InferFilters<WireFormat<T['$inferSelect']>>;
+    insertInput: InferInsertInput<T>;
+    updateInput: InferUpdateInput<T>;
+    orderBy: InferOrderBy<T>;
+} : never;
+export type InferEntityDefs<TSchema, TConfig = Record<string, never>> = {
+    [K in keyof ExtractTables<TSchema> as K extends ExcludedNames<TConfig> ? never : K extends string ? K : never]: BuildEntityDef<TSchema, ExtractTables<TSchema>[K]>;
+};
+export {};

package/packages/client/dist/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "@drizzle-graphql-suite/client",
+  "version": "0.5.0",
+  "description": "Type-safe GraphQL client with entity-based API and full Drizzle type inference",
+  "license": "MIT",
+  "author": "https://github.com/dmythro",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/annexare/drizzle-graphql-suite.git",
+    "directory": "packages/client"
+  },
+  "homepage": "https://github.com/annexare/drizzle-graphql-suite/tree/main/packages/client#readme",
+  "keywords": [
+    "drizzle",
+    "graphql",
+    "client",
+    "type-safe",
+    "typescript",
+    "orm",
+    "query-builder"
+  ],
+  "type": "module",
+  "publishConfig": {
+    "access": "public"
+  },
+  "main": "./index.js",
+  "types": "./index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./index.d.ts",
+      "import": "./index.js"
+    }
+  },
+  "peerDependencies": {
+    "drizzle-orm": ">=0.44.0"
+  }
+}

package/packages/client/dist/query-builder.d.ts

@@ -0,0 +1,12 @@
+import type { EntityDescriptor, SchemaDescriptor } from './types';
+export type BuiltQuery = {
+    query: string;
+    variables: Record<string, unknown>;
+    operationName: string;
+};
+export declare function buildListQuery(entityName: string, entityDef: EntityDescriptor, schema: SchemaDescriptor, select: Record<string, unknown>, hasWhere: boolean, hasOrderBy: boolean, hasLimit: boolean, hasOffset: boolean): BuiltQuery;
+export declare function buildSingleQuery(entityName: string, entityDef: EntityDescriptor, schema: SchemaDescriptor, select: Record<string, unknown>, hasWhere: boolean, hasOrderBy: boolean, hasOffset: boolean): BuiltQuery;
+export declare function buildCountQuery(entityName: string, entityDef: EntityDescriptor, hasWhere: boolean): BuiltQuery;
+export declare function buildInsertMutation(entityName: string, entityDef: EntityDescriptor, schema: SchemaDescriptor, returning: Record<string, unknown> | undefined, isSingle: boolean): BuiltQuery;
+export declare function buildUpdateMutation(entityName: string, entityDef: EntityDescriptor, schema: SchemaDescriptor, returning: Record<string, unknown> | undefined, hasWhere: boolean): BuiltQuery;
+export declare function buildDeleteMutation(entityName: string, entityDef: EntityDescriptor, schema: SchemaDescriptor, returning: Record<string, unknown> | undefined, hasWhere: boolean): BuiltQuery;

package/packages/client/dist/schema-builder.d.ts

@@ -0,0 +1,15 @@
+import type { SchemaDescriptor } from './types';
+export type ClientSchemaConfig = {
+    mutations?: boolean;
+    suffixes?: {
+        list?: string;
+        single?: string;
+    };
+    tables?: {
+        exclude?: readonly string[];
+    };
+    pruneRelations?: Record<string, false | 'leaf' | {
+        only: string[];
+    }>;
+};
+export declare function buildSchemaDescriptor(schema: Record<string, unknown>, config?: ClientSchemaConfig): SchemaDescriptor;

package/packages/client/dist/types.d.ts

@@ -0,0 +1,45 @@
+export type RelationDef = {
+    entity: string;
+    type: 'one' | 'many';
+};
+export type EntityDef = {
+    fields: Record<string, unknown>;
+    relations: Record<string, RelationDef>;
+    filters?: Record<string, unknown>;
+    insertInput?: Record<string, unknown>;
+    updateInput?: Record<string, unknown>;
+    orderBy?: Record<string, unknown>;
+};
+export type AnyEntityDefs = Record<string, EntityDef>;
+export type EntityDescriptor = {
+    queryName: string;
+    queryListName: string;
+    countName: string;
+    insertName: string;
+    insertSingleName: string;
+    updateName: string;
+    deleteName: string;
+    fields: readonly string[];
+    relations: Record<string, {
+        entity: string;
+        type: 'one' | 'many';
+    }>;
+};
+export type SchemaDescriptor = Record<string, EntityDescriptor>;
+export type SelectInput<TDefs extends AnyEntityDefs, TEntity extends EntityDef> = {
+    [K in keyof TEntity['fields'] | keyof TEntity['relations']]?: K extends keyof TEntity['relations'] ? TEntity['relations'][K] extends RelationDef ? TEntity['relations'][K]['entity'] extends keyof TDefs ? SelectInput<TDefs, TDefs[TEntity['relations'][K]['entity']]> : never : never : K extends keyof TEntity['fields'] ? true : never;
+};
+type Simplify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+export type InferResult<TDefs extends AnyEntityDefs, TEntity extends EntityDef, TSelect> = Simplify<InferScalars<TEntity, TSelect> & InferRelations<TDefs, TEntity, TSelect>>;
+type InferScalars<TEntity extends EntityDef, TSelect> = Pick<TEntity['fields'], keyof TSelect & keyof TEntity['fields']>;
+type InferRelations<TDefs extends AnyEntityDefs, TEntity extends EntityDef, TSelect> = {
+    [K in keyof TSelect & keyof TEntity['relations'] as TSelect[K] extends Record<string, unknown> ? K : never]: TEntity['relations'][K] extends RelationDef ? TEntity['relations'][K]['entity'] extends keyof TDefs ? TEntity['relations'][K]['type'] extends 'many' ? InferResult<TDefs, TDefs[TEntity['relations'][K]['entity']], TSelect[K]>[] : InferResult<TDefs, TDefs[TEntity['relations'][K]['entity']], TSelect[K]> | null : never : never;
+};
+export type ClientConfig<TSchema extends SchemaDescriptor = SchemaDescriptor> = {
+    url: string | (() => string);
+    schema: TSchema;
+    headers?: HeadersInit | (() => HeadersInit | Promise<HeadersInit>);
+};
+export {};