@kavo/graphql 0.4.0 → 0.6.0

package/dist/discovery.d.ts

@@ -1,8 +1,8 @@
 import type { ClassRef, EntityId } from "@kavo/core";
 import type { GraphQLSchema } from "graphql";
-import type { BoundCrudService } from "./schema.js";
-/** The minimum a host framework needs to hand this package about one `@Crud` entity. */
-export interface CrudEntityRef {
+import type { BoundKavoService } from "./schema.js";
+/** The minimum a host framework needs to hand this package about one `@Kavo` entity. */
+export interface KavoEntityRef {
     readonly entity: ClassRef;
 }
 /**
@@ -10,18 +10,18 @@ export interface CrudEntityRef {
  * GraphQL types and put them all on one schema." Two things stay
  * deliberately outside this package, supplied by the caller instead:
  *
- * - **How to enumerate `@Crud` entities** — `@kavo/nest`'s `getCrudEntities()`,
+ * - **How to enumerate `@Kavo` entities** — `@kavo/nest`'s `getKavoEntities()`,
  *   a plain array an Express/Fastify/Next.js app builds by hand, or any
  *   other host's own registry.
  * - **How to resolve a bound service for one entity** — `@kavo/nest`'s
- *   `ModuleRef` + `getCrudServiceToken`, a plain `Map`, or whatever DI
+ *   `ModuleRef` + `getKavoServiceToken`, a plain `Map`, or whatever DI
  *   container that host uses.
  *
  * This function only ever touches `@kavo/core` shapes and this package's
  * own type registry — never a host framework — so the same call works
- * from `@kavo/nest`'s `BaseCrudGraphQLController` today and from a future
+ * from `@kavo/nest`'s `BaseKavoGraphQLController` today and from a future
  * `@kavo/express`/`@kavo/fastify`/`@kavo/nextjs` binding without either
  * package importing the other (ADR-0016).
  */
-export declare function resolveCrudGraphQLSchema(entities: readonly CrudEntityRef[], resolveService: (entity: ClassRef) => BoundCrudService<object, EntityId, unknown, unknown, unknown, unknown, unknown>): GraphQLSchema;
+export declare function resolveKavoGraphQLSchema(entities: readonly KavoEntityRef[], resolveService: (entity: ClassRef) => BoundKavoService<object, EntityId, unknown, unknown, unknown, unknown, unknown>): GraphQLSchema;
 //# sourceMappingURL=discovery.d.ts.map

package/dist/discovery.js

@@ -1,32 +1,32 @@
-import { mergeCrudGraphQLSchemas } from "./schema.js";
-import { getCrudGraphQLTypes } from "./registry.js";
+import { mergeKavoGraphQLSchemas } from "./schema.js";
+import { getKavoGraphQLTypes } from "./registry.js";
 /**
  * The host-agnostic half of "discover every entity that registered
  * GraphQL types and put them all on one schema." Two things stay
  * deliberately outside this package, supplied by the caller instead:
  *
- * - **How to enumerate `@Crud` entities** — `@kavo/nest`'s `getCrudEntities()`,
+ * - **How to enumerate `@Kavo` entities** — `@kavo/nest`'s `getKavoEntities()`,
  *   a plain array an Express/Fastify/Next.js app builds by hand, or any
  *   other host's own registry.
  * - **How to resolve a bound service for one entity** — `@kavo/nest`'s
- *   `ModuleRef` + `getCrudServiceToken`, a plain `Map`, or whatever DI
+ *   `ModuleRef` + `getKavoServiceToken`, a plain `Map`, or whatever DI
  *   container that host uses.
  *
  * This function only ever touches `@kavo/core` shapes and this package's
  * own type registry — never a host framework — so the same call works
- * from `@kavo/nest`'s `BaseCrudGraphQLController` today and from a future
+ * from `@kavo/nest`'s `BaseKavoGraphQLController` today and from a future
  * `@kavo/express`/`@kavo/fastify`/`@kavo/nextjs` binding without either
  * package importing the other (ADR-0016).
  */
-export function resolveCrudGraphQLSchema(entities, resolveService) {
+export function resolveKavoGraphQLSchema(entities, resolveService) {
     const bindings = [];
     for (const { entity } of entities) {
-        const types = getCrudGraphQLTypes(entity);
+        const types = getKavoGraphQLTypes(entity);
         if (types === undefined) {
             continue;
         }
         bindings.push({ name: entity.name, service: resolveService(entity), ...types });
     }
-    return mergeCrudGraphQLSchemas(bindings);
+    return mergeKavoGraphQLSchemas(bindings);
 }
 //# sourceMappingURL=discovery.js.map

package/dist/index.d.ts

@@ -1,5 +1,5 @@
-export { createCrudGraphQLSchema, mergeCrudGraphQLSchemas, type CrudGraphQLOptions, type BoundCrudService, } from "./schema.js";
-export { registerCrudGraphQLTypes, getCrudGraphQLTypes, type CrudGraphQLTypes } from "./registry.js";
-export { resolveCrudGraphQLSchema, type CrudEntityRef } from "./discovery.js";
+export { createKavoGraphQLSchema, mergeKavoGraphQLSchemas, type KavoGraphQLOptions, type BoundKavoService, } from "./schema.js";
+export { registerKavoGraphQLTypes, getKavoGraphQLTypes, type KavoGraphQLTypes } from "./registry.js";
+export { resolveKavoGraphQLSchema, type KavoEntityRef } from "./discovery.js";
 export { GraphQLJSON } from "./json-scalar.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -1,5 +1,5 @@
-export { createCrudGraphQLSchema, mergeCrudGraphQLSchemas, } from "./schema.js";
-export { registerCrudGraphQLTypes, getCrudGraphQLTypes } from "./registry.js";
-export { resolveCrudGraphQLSchema } from "./discovery.js";
+export { createKavoGraphQLSchema, mergeKavoGraphQLSchemas, } from "./schema.js";
+export { registerKavoGraphQLTypes, getKavoGraphQLTypes } from "./registry.js";
+export { resolveKavoGraphQLSchema } from "./discovery.js";
 export { GraphQLJSON } from "./json-scalar.js";
 //# sourceMappingURL=index.js.map

package/dist/registry.d.ts

@@ -2,13 +2,13 @@ import type { ClassRef } from "@kavo/core";
 import type { GraphQLInputObjectType, GraphQLObjectType } from "graphql";
 /**
  * GraphQL object/input types (and which mutations to expose) for one
- * entity — the hand-written part `registerCrudGraphQLTypes` attaches to a
- * class. Each mutation flag/input mirrors `CrudGraphQLOptions` in
+ * entity — the hand-written part `registerKavoGraphQLTypes` attaches to a
+ * class. Each mutation flag/input mirrors `KavoGraphQLOptions` in
  * `schema.ts` one for one — omit any of them to leave that mutation off
- * the schema for this entity, same opt-in shape `@Crud`'s own `operations`
+ * the schema for this entity, same opt-in shape `@Kavo`'s own `operations`
  * config uses on the REST side.
  */
-export interface CrudGraphQLTypes {
+export interface KavoGraphQLTypes {
     readonly itemType: GraphQLObjectType;
     /** Omit to leave the `create<Name>` mutation off the schema for this entity. */
     readonly createInputType?: GraphQLInputObjectType;
@@ -25,14 +25,14 @@ export interface CrudGraphQLTypes {
 }
 /**
  * Attaches GraphQL types to an entity once, next to its DTOs — the
- * counterpart of `@kavo/nest`'s `getCrudEntities()`: a consumer can walk
- * every `@Crud` entity and look up its GraphQL types here, wiring a merged
- * schema with no per-entity list of its own (see `resolveCrudGraphQLSchema`
+ * counterpart of `@kavo/nest`'s `getKavoEntities()`: a consumer can walk
+ * every `@Kavo` entity and look up its GraphQL types here, wiring a merged
+ * schema with no per-entity list of its own (see `resolveKavoGraphQLSchema`
  * in `discovery.ts`, which does exactly that). An entity with no
  * registration here simply has no GraphQL surface — opt-in, not implied by
- * `@Crud` alone. Process-wide, same scope as `@kavo/nest`'s own registry.
+ * `@Kavo` alone. Process-wide, same scope as `@kavo/nest`'s own registry.
  */
-export declare function registerCrudGraphQLTypes(entity: ClassRef, types: CrudGraphQLTypes): void;
-/** The types `registerCrudGraphQLTypes` attached to `entity`, or `undefined` if it never registered any. */
-export declare function getCrudGraphQLTypes(entity: ClassRef): CrudGraphQLTypes | undefined;
+export declare function registerKavoGraphQLTypes(entity: ClassRef, types: KavoGraphQLTypes): void;
+/** The types `registerKavoGraphQLTypes` attached to `entity`, or `undefined` if it never registered any. */
+export declare function getKavoGraphQLTypes(entity: ClassRef): KavoGraphQLTypes | undefined;
 //# sourceMappingURL=registry.d.ts.map

package/dist/registry.js

@@ -1,18 +1,18 @@
 const typeRegistry = new Map();
 /**
  * Attaches GraphQL types to an entity once, next to its DTOs — the
- * counterpart of `@kavo/nest`'s `getCrudEntities()`: a consumer can walk
- * every `@Crud` entity and look up its GraphQL types here, wiring a merged
- * schema with no per-entity list of its own (see `resolveCrudGraphQLSchema`
+ * counterpart of `@kavo/nest`'s `getKavoEntities()`: a consumer can walk
+ * every `@Kavo` entity and look up its GraphQL types here, wiring a merged
+ * schema with no per-entity list of its own (see `resolveKavoGraphQLSchema`
  * in `discovery.ts`, which does exactly that). An entity with no
  * registration here simply has no GraphQL surface — opt-in, not implied by
- * `@Crud` alone. Process-wide, same scope as `@kavo/nest`'s own registry.
+ * `@Kavo` alone. Process-wide, same scope as `@kavo/nest`'s own registry.
  */
-export function registerCrudGraphQLTypes(entity, types) {
+export function registerKavoGraphQLTypes(entity, types) {
     typeRegistry.set(entity, types);
 }
-/** The types `registerCrudGraphQLTypes` attached to `entity`, or `undefined` if it never registered any. */
-export function getCrudGraphQLTypes(entity) {
+/** The types `registerKavoGraphQLTypes` attached to `entity`, or `undefined` if it never registered any. */
+export function getKavoGraphQLTypes(entity) {
     return typeRegistry.get(entity);
 }
 //# sourceMappingURL=registry.js.map

package/dist/schema.d.ts

@@ -1,9 +1,9 @@
 import { GraphQLObjectType, GraphQLSchema, type GraphQLFieldConfig, type GraphQLInputObjectType } from "graphql";
-import type { DefaultCrudService, EntityId } from "@kavo/core";
+import type { DefaultKavoService, EntityId } from "@kavo/core";
 /**
  * What a query/mutation resolver in this binding actually calls — the
  * transport-agnostic programmatic surface `createCrud` returns. Kept as a
- * structural type (not `DefaultCrudService` itself) so a caller only has to
+ * structural type (not `DefaultKavoService` itself) so a caller only has to
  * satisfy the handful of methods a schema actually wires up, the same way
  * `@kavo/nest`'s standard-operation routes bind to it. Exported (not just
  * internal) so `discovery.ts`'s host-agnostic resolver callback can name it.
@@ -11,12 +11,12 @@ import type { DefaultCrudService, EntityId } from "@kavo/core";
  * Every standard operation is picked unconditionally — whether a given
  * field actually reaches the schema is decided per entity by which
  * `*InputType`/`include*` options `crudFields` receives, mirroring how
- * `@Crud`'s own `operations` config opts entities in or out on the REST
+ * `@Kavo`'s own `operations` config opts entities in or out on the REST
  * side. Calling `restoreOne`/`purgeOne` against an entity that never
  * declared soft delete still raises `OperationDisabledException` from the
  * engine itself — this binding does not re-check that, same as REST.
  */
-export type BoundCrudService<Entity extends object, Id extends EntityId, CreateDto, UpdateDto, PatchDto, ItemDto, ListDto> = Pick<DefaultCrudService<Entity, Id, CreateDto, UpdateDto, PatchDto, unknown, ItemDto, ListDto>, "findOne" | "findMany" | "createOne" | "updateOne" | "patchOne" | "deleteOne" | "restoreOne" | "purgeOne">;
+export type BoundKavoService<Entity extends object, Id extends EntityId, CreateDto, UpdateDto, PatchDto, ItemDto, ListDto> = Pick<DefaultKavoService<Entity, Id, CreateDto, UpdateDto, PatchDto, unknown, ItemDto, ListDto>, "findOne" | "findMany" | "createOne" | "updateOne" | "patchOne" | "deleteOne" | "restoreOne" | "purgeOne">;
 /**
  * One entity's GraphQL binding: a query root (`<name>`/`<name>s`) plus
  * whichever mutations its options ask for — every resolver a direct call
@@ -25,10 +25,10 @@ export type BoundCrudService<Entity extends object, Id extends EntityId, CreateD
  * that field never reaches the schema, the same "declare what you want"
  * shape `createInputType` already had.
  */
-export interface CrudGraphQLOptions<Entity extends object, Id extends EntityId, CreateDto, UpdateDto, PatchDto, ItemDto, ListDto> {
+export interface KavoGraphQLOptions<Entity extends object, Id extends EntityId, CreateDto, UpdateDto, PatchDto, ItemDto, ListDto> {
     /** Singular, capitalized entity name — becomes `Query.<lowerName>` / `<Name>List` / `createName` / etc. */
     readonly name: string;
-    readonly service: BoundCrudService<Entity, Id, CreateDto, UpdateDto, PatchDto, ItemDto, ListDto>;
+    readonly service: BoundKavoService<Entity, Id, CreateDto, UpdateDto, PatchDto, ItemDto, ListDto>;
     readonly itemType: GraphQLObjectType;
     /** Omit to leave the `create<Name>` mutation off the schema. */
     readonly createInputType?: GraphQLInputObjectType;
@@ -44,12 +44,12 @@ export interface CrudGraphQLOptions<Entity extends object, Id extends EntityId,
     readonly purgeOne?: boolean;
 }
 /**
- * Field maps for one entity's binding — the unit `createCrudGraphQLSchema`
- * wraps and `mergeCrudGraphQLSchemas`/`resolveCrudGraphQLSchema` combine.
+ * Field maps for one entity's binding — the unit `createKavoGraphQLSchema`
+ * wraps and `mergeKavoGraphQLSchemas`/`resolveKavoGraphQLSchema` combine.
  * Not exported from the barrel: an internal building block, same status as
  * `lowerFirst`.
  */
-export declare function crudFields<Entity extends object, Id extends EntityId, CreateDto, UpdateDto, PatchDto, ItemDto, ListDto>(options: CrudGraphQLOptions<Entity, Id, CreateDto, UpdateDto, PatchDto, ItemDto, ListDto>): {
+export declare function crudFields<Entity extends object, Id extends EntityId, CreateDto, UpdateDto, PatchDto, ItemDto, ListDto>(options: KavoGraphQLOptions<Entity, Id, CreateDto, UpdateDto, PatchDto, ItemDto, ListDto>): {
     query: Record<string, GraphQLFieldConfig<unknown, unknown>>;
     mutation: Record<string, GraphQLFieldConfig<unknown, unknown>>;
 };
@@ -61,18 +61,18 @@ export declare function crudFields<Entity extends object, Id extends EntityId, C
  * resolver delegates straight to the bound service, which itself is sugar
  * over `engine.execute` — the identical pipeline REST runs.
  *
- * For an app with more than one entity, prefer `mergeCrudGraphQLSchemas` (or
- * `resolveCrudGraphQLSchema` for a framework-driven registry) — they put
+ * For an app with more than one entity, prefer `mergeKavoGraphQLSchemas` (or
+ * `resolveKavoGraphQLSchema` for a framework-driven registry) — they put
  * every entity's fields on one `Query`/`Mutation` root instead of one
  * schema (and one mounted endpoint) per entity.
  */
-export declare function createCrudGraphQLSchema<Entity extends object, Id extends EntityId, CreateDto, UpdateDto, PatchDto, ItemDto, ListDto>(options: CrudGraphQLOptions<Entity, Id, CreateDto, UpdateDto, PatchDto, ItemDto, ListDto>): GraphQLSchema;
+export declare function createKavoGraphQLSchema<Entity extends object, Id extends EntityId, CreateDto, UpdateDto, PatchDto, ItemDto, ListDto>(options: KavoGraphQLOptions<Entity, Id, CreateDto, UpdateDto, PatchDto, ItemDto, ListDto>): GraphQLSchema;
 /**
  * Combines several entities' bindings onto one `Query`/`Mutation` root —
  * the shape an app actually wants: one `/graphql` endpoint for every
- * `@Crud` entity, not one per entity. Each entry is the same options shape
- * `createCrudGraphQLSchema` takes; field names are namespaced by each
+ * `@Kavo` entity, not one per entity. Each entry is the same options shape
+ * `createKavoGraphQLSchema` takes; field names are namespaced by each
  * entity's own `name`, so entries never collide with each other.
  */
-export declare function mergeCrudGraphQLSchemas(bindings: readonly CrudGraphQLOptions<object, EntityId, unknown, unknown, unknown, unknown, unknown>[]): GraphQLSchema;
+export declare function mergeKavoGraphQLSchemas(bindings: readonly KavoGraphQLOptions<object, EntityId, unknown, unknown, unknown, unknown, unknown>[]): GraphQLSchema;
 //# sourceMappingURL=schema.d.ts.map

package/dist/schema.js

@@ -18,8 +18,8 @@ function lowerFirst(value) {
     return value.charAt(0).toLowerCase() + value.slice(1);
 }
 /**
- * Field maps for one entity's binding — the unit `createCrudGraphQLSchema`
- * wraps and `mergeCrudGraphQLSchemas`/`resolveCrudGraphQLSchema` combine.
+ * Field maps for one entity's binding — the unit `createKavoGraphQLSchema`
+ * wraps and `mergeKavoGraphQLSchemas`/`resolveKavoGraphQLSchema` combine.
  * Not exported from the barrel: an internal building block, same status as
  * `lowerFirst`.
  */
@@ -117,12 +117,12 @@ export function crudFields(options) {
  * resolver delegates straight to the bound service, which itself is sugar
  * over `engine.execute` — the identical pipeline REST runs.
  *
- * For an app with more than one entity, prefer `mergeCrudGraphQLSchemas` (or
- * `resolveCrudGraphQLSchema` for a framework-driven registry) — they put
+ * For an app with more than one entity, prefer `mergeKavoGraphQLSchemas` (or
+ * `resolveKavoGraphQLSchema` for a framework-driven registry) — they put
  * every entity's fields on one `Query`/`Mutation` root instead of one
  * schema (and one mounted endpoint) per entity.
  */
-export function createCrudGraphQLSchema(options) {
+export function createKavoGraphQLSchema(options) {
     const { query, mutation } = crudFields(options);
     return new GraphQLSchema({
         query: new GraphQLObjectType({ name: "Query", fields: query }),
@@ -132,11 +132,11 @@ export function createCrudGraphQLSchema(options) {
 /**
  * Combines several entities' bindings onto one `Query`/`Mutation` root —
  * the shape an app actually wants: one `/graphql` endpoint for every
- * `@Crud` entity, not one per entity. Each entry is the same options shape
- * `createCrudGraphQLSchema` takes; field names are namespaced by each
+ * `@Kavo` entity, not one per entity. Each entry is the same options shape
+ * `createKavoGraphQLSchema` takes; field names are namespaced by each
  * entity's own `name`, so entries never collide with each other.
  */
-export function mergeCrudGraphQLSchemas(bindings) {
+export function mergeKavoGraphQLSchemas(bindings) {
     const query = {};
     const mutation = {};
     for (const binding of bindings) {
@@ -149,10 +149,10 @@ export function mergeCrudGraphQLSchemas(bindings) {
         // or more fields.`) — graphql-js would only report that cryptically, on
         // the first request, deep inside `graphql()`'s own schema validation.
         // Failing fast here, at schema-build time, with a message that names the
-        // actual fix, is what `resolveCrudGraphQLSchema` (zero entities
+        // actual fix, is what `resolveKavoGraphQLSchema` (zero entities
         // discovered) relies on to fail at boot instead of at request time.
-        throw new ConfigurationException("GraphQLSchema", "bindings", "no entity registered any GraphQL types — call registerCrudGraphQLTypes(Entity, {...}) " +
-            "for at least one @Crud entity before enabling a GraphQL endpoint");
+        throw new ConfigurationException("GraphQLSchema", "bindings", "no entity registered any GraphQL types — call registerKavoGraphQLTypes(Entity, {...}) " +
+            "for at least one @Kavo entity before enabling a GraphQL endpoint");
     }
     return new GraphQLSchema({
         query: new GraphQLObjectType({ name: "Query", fields: query }),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kavo/graphql",
-  "version": "0.4.0",
+  "version": "0.6.0",
   "description": "Kavo GraphQL binding — builds a GraphQL schema over a createCrud service, delegating every resolver to the same engine REST uses.",
   "license": "MIT",
   "repository": {
@@ -23,16 +23,16 @@
   "files": [
     "dist"
   ],
-  "scripts": {
-    "build": "tsc -b"
-  },
   "dependencies": {
-    "@kavo/core": "workspace:^"
+    "@kavo/core": "^0.6.0"
   },
   "peerDependencies": {
     "graphql": "^17.0.0"
   },
   "devDependencies": {
     "graphql": "^17.0.0"
+  },
+  "scripts": {
+    "build": "tsc -b"
   }
-}
+}