@usegraft/sdk-sveltekit 0.0.0-canary-20260901211203

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Anderson Joseph
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,104 @@
+# @usegraft/sdk-sveltekit
+
+> SvelteKit adapter: typed content reads and endpoint mounts over the same handlers every other surface serves.
+
+Part of [Graft](https://github.com/AndersonDesign1/graft), a CMS built so an AI agent is the primary operator.
+
+## Install
+
+```bash
+npm i @usegraft/sdk-sveltekit
+```
+
+## Read content
+
+Build the handle in `$lib/server/`, so SvelteKit's server-only enforcement guards it. This client holds a database handle and must never reach the browser.
+
+```ts
+// src/lib/server/graft.ts
+import { DATABASE_URL } from "$env/static/private";
+import { createDb } from "@usegraft/db";
+import { createGraft } from "@usegraft/sdk-sveltekit";
+import { collections } from "../../../graft.config";
+
+export const graft = createGraft({ db: createDb(DATABASE_URL).db, collections });
+```
+
+```ts
+// src/routes/[slug]/+page.server.ts
+import { error } from "@sveltejs/kit";
+import { graft } from "$lib/server/graft";
+import type { PageServerLoad } from "./$types";
+
+export const load: PageServerLoad = async ({ params }) => {
+  const page = await graft.getContent("pages", params.slug);
+  if (!page) error(404);
+  return { page };
+};
+```
+
+Return types come from your `defineCollection` schemas, so a renamed field is a build error rather than a runtime `undefined`.
+
+There is no request-level memo here, because `React.cache` has no SvelteKit equivalent. Reads go straight to the index from server `load` functions and `+server.ts` endpoints.
+
+## Read with no database
+
+Pass `index` instead of `db` and the same surface reads the SQLite artifact `graft compile` writes.
+
+```ts
+import { openStaticIndex } from "@usegraft/db";
+
+export const graft = createGraft({
+  index: await openStaticIndex(".graft/index.db"),
+  collections,
+});
+```
+
+## Mount the runtime
+
+`graftRoute` binds a Graft handler to a `+server.ts` endpoint, so typed functions and MCP are served from your own app rather than a separate process. It takes the handler, not a config object: SvelteKit hands over a `RequestEvent`, and the handlers want its `request`.
+
+```ts
+// src/routes/api/fn/[name]/+server.ts
+import { createFunctionsHandler } from "@usegraft/core";
+import { graftRoute } from "@usegraft/sdk-sveltekit";
+
+const handler = createFunctionsHandler({ db, collections, functions });
+
+export const POST = graftRoute(handler);
+export const GET = graftRoute(handler); // 405s with Allow and a fix
+```
+
+```ts
+// src/routes/api/mcp/+server.ts
+import { createGraftMcpHandler } from "@usegraft/mcp";
+import { graftRoute } from "@usegraft/sdk-sveltekit";
+
+export const POST = graftRoute(createGraftMcpHandler({ db, collections, functions, actor }));
+```
+
+The parameter is typed structurally as `{ request: Request }`, so this package needs no `@sveltejs/kit` dependency and every `RequestEvent` satisfies it.
+
+## MDX
+
+Bodies come back as authored source. Render them with mdsvex or your own pipeline rather than a runtime evaluator, which is why this package ships no `MdxBody` equivalent.
+
+## Cache invalidation
+
+SvelteKit has no tag-based data cache, so the [`@usegraft/sdk-core`](https://www.npmjs.com/package/@usegraft/sdk-core) tag contract maps onto HTTP. Stamp `tagsFor(...)` into a CDN surrogate-key header with `setHeaders` in `load`, and purge `tagsForChanges(branch, changeSet)` from your compile webhook.
+
+```ts
+export const load: PageServerLoad = async ({ params, setHeaders }) => {
+  const page = await graft.getContent("pages", params.slug);
+  setHeaders({ "Cache-Tag": tagsFor("main", "pages", params.slug).join(",") });
+  return { page };
+};
+```
+
+## Bundling
+
+`node:sqlite` backs the static index and must stay external to the client bundle. Keeping the handle in `$lib/server/` is what guarantees that.
+
+---
+
+MIT. [Repository](https://github.com/AndersonDesign1/graft) · [Changelog](https://github.com/AndersonDesign1/graft/blob/main/packages/sdk-sveltekit/CHANGELOG.md)

package/dist/index.d.ts

@@ -0,0 +1,69 @@
+import { DbClientOptions } from '@usegraft/sdk-core/db';
+import { AnyCollection, ReadOptions, Document, ListOptions, SearchOptions, SearchHit, GraftClient, ClientOptions } from '@usegraft/sdk-core';
+export { AnyCollection, ChangeSet, ClientOptions, Document, GraftClient, ListOptions, ReadOptions, SearchHit, SearchOptions, TAG_NAMESPACE, collectionTag, createClient, documentTag, tagsFor, tagsForChanges, toDocument } from '@usegraft/sdk-core';
+
+/**
+ * SvelteKit adapter over @usegraft/sdk-core — the same `getContent` /
+ * `listContent` / `searchContent` surface as @usegraft/sdk-next, so a schema
+ * types every read identically across frameworks.
+ *
+ * No request-level memo (sdk-next's React.cache has no SvelteKit
+ * equivalent): reads go straight to Postgres from server `load` functions
+ * and `+server.ts` endpoints. Server-only by nature (it holds a database
+ * handle) — construct it in `$lib/server/` so SvelteKit's server-only
+ * enforcement guards it, and never import it into client code.
+ *
+ * Caching: SvelteKit has no tag-based data cache, so the Phase 4 tag
+ * contract maps onto HTTP — stamp `tagsFor(...)` into a CDN surrogate-key
+ * header (`Cache-Tag` / `Surrogate-Key`) via `setHeaders` in `load`, and
+ * purge `tagsForChanges(branch, changeSet)` from your compile webhook.
+ */
+
+interface Graft<TCollections extends Record<string, AnyCollection>> {
+    /** Typed getDocument. */
+    getContent<K extends keyof TCollections & string>(collection: K, slug: string, options?: ReadOptions): Promise<Document<TCollections[K]> | null>;
+    /** Typed listDocuments. */
+    listContent<K extends keyof TCollections & string>(collection: K, options?: ListOptions): Promise<Document<TCollections[K]>[]>;
+    /** Typed searchDocuments (full-text, best-ranked first). */
+    searchContent<K extends keyof TCollections & string>(collection: K, query: string, options?: SearchOptions): Promise<SearchHit<TCollections[K]>[]>;
+    /** The underlying sdk-core client, for anything the helpers don't cover. */
+    client: GraftClient<TCollections>;
+}
+/**
+ * Either an index this adapter reads through, or a Postgres handle it builds
+ * the reader for. Two shapes rather than one optional field so that neither can
+ * be omitted: `createClient` no longer accepts `db`, because taking it there
+ * meant every consumer of `@usegraft/sdk-core` — the browser client included —
+ * carried a Postgres driver in its dependency graph.
+ */
+type GraftOptions<TCollections extends Record<string, AnyCollection>> = ClientOptions<TCollections> | DbClientOptions<TCollections>;
+declare function createGraft<TCollections extends Record<string, AnyCollection>>(options: GraftOptions<TCollections>): Graft<TCollections>;
+
+/**
+ * Mounting the Graft runtime in SvelteKit — `+server.ts` endpoints are
+ * already Web-standard, so the "adapter" is one property access: SvelteKit
+ * hands a RequestEvent, the handlers want its `request`.
+ *
+ * ```ts
+ * // src/routes/api/fn/[name]/+server.ts
+ * import { createFunctionsHandler } from "@usegraft/core";
+ * import { graftRoute } from "@usegraft/sdk-sveltekit";
+ * const handler = createFunctionsHandler({ … });
+ * export const POST = graftRoute(handler);
+ * export const GET = graftRoute(handler);   // 405s with Allow + fix
+ *
+ * // src/routes/api/mcp/+server.ts
+ * import { createGraftMcpHandler } from "@usegraft/mcp";
+ * export const POST = graftRoute(createGraftMcpHandler({ … }));
+ * ```
+ *
+ * Typed structurally (`{ request: Request }`) so this package needs no
+ * @sveltejs/kit dependency — every RequestEvent satisfies it.
+ */
+type FetchHandler = (request: Request) => Promise<Response>;
+/** A SvelteKit RequestHandler (or anything event-shaped) over a Graft handler. */
+declare function graftRoute(handler: FetchHandler): (event: {
+    request: Request;
+}) => Promise<Response>;
+
+export { type FetchHandler, type Graft, type GraftOptions, createGraft, graftRoute };

package/dist/index.js

@@ -0,0 +1,41 @@
+// src/graft.ts
+import { createDbClient } from "@usegraft/sdk-core/db";
+import {
+  createClient
+} from "@usegraft/sdk-core";
+function createGraft(options) {
+  const client = "db" in options ? createDbClient(options) : createClient(options);
+  return {
+    client,
+    getContent: (collection, slug, opts) => client.getDocument(collection, slug, opts),
+    listContent: (collection, opts) => client.listDocuments(collection, opts),
+    searchContent: (collection, query, opts) => client.searchDocuments(collection, query, opts)
+  };
+}
+
+// src/routes.ts
+function graftRoute(handler) {
+  return (event) => handler(event.request);
+}
+
+// src/index.ts
+import {
+  createClient as createClient2,
+  toDocument,
+  collectionTag,
+  documentTag,
+  tagsFor,
+  tagsForChanges,
+  TAG_NAMESPACE
+} from "@usegraft/sdk-core";
+export {
+  TAG_NAMESPACE,
+  collectionTag,
+  createClient2 as createClient,
+  createGraft,
+  documentTag,
+  graftRoute,
+  tagsFor,
+  tagsForChanges,
+  toDocument
+};

package/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "@usegraft/sdk-sveltekit",
+  "version": "0.0.0-canary-20260901211203",
+  "description": "SvelteKit adapter: typed content reads and endpoint mounts over Graft's stateless handlers.",
+  "keywords": [
+    "agent",
+    "ai",
+    "cms",
+    "graft",
+    "headless-cms",
+    "mcp",
+    "svelte",
+    "sveltekit",
+    "typescript"
+  ],
+  "homepage": "https://github.com/AndersonDesign1/graft#readme",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/AndersonDesign1/graft.git",
+    "directory": "packages/sdk-sveltekit"
+  },
+  "files": [
+    "dist"
+  ],
+  "type": "module",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@usegraft/db": "0.0.0-canary-20260901211203",
+    "@usegraft/sdk-core": "0.0.0-canary-20260901211203"
+  },
+  "devDependencies": {
+    "@usegraft/core": "0.0.0-canary-20260901211203"
+  },
+  "engines": {
+    "node": ">=22.16"
+  },
+  "scripts": {
+    "build": "tsup src/index.ts --format esm --dts --clean",
+    "dev": "tsup src/index.ts --format esm --watch",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run --passWithNoTests"
+  }
+}