@aihu-plugin/drizzle 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Fellwork
+
+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,123 @@
+# @aihu-plugin/drizzle
+
+> **Aihu** — agentic discovery and interaction, for human purpose.
+
+Drizzle ORM data adapter for aihu — typed createResource fetchers and defineLoader helpers (Postgres / SQLite / libSQL).
+
+Held-private workspace package. Not yet published to npm.
+
+> **Status:** Held private — not yet published to npm. See [v1.1 roadmap](../../docs/roadmap/SUMMARY.md) for ratification gating (e.g. RFC #56 live-binding for `@aihu/plugin` enforcement).
+
+<!-- BEGIN_HANDWRITTEN: prose -->
+Server-only. Wraps a Drizzle query into the two data-access shapes aihu uses:
+
+```ts
+import { drizzle } from 'drizzle-orm/libsql'
+import { eq } from 'drizzle-orm'
+import { createResource } from '@aihu-plugin/data'
+import { defineRoute } from '@aihu/server'
+import { createDrizzleResource, drizzleLoader } from '@aihu-plugin/drizzle'
+
+const db = drizzle(client)
+
+// 1. A createResource-compatible fetcher: (key: string) => Promise<T>
+const fetchUser = createDrizzleResource(
+  db,
+  (db, id: number) => db.select().from(users).where(eq(users.id, id)),
+  { parseKey: Number },
+)
+const user = createResource(idSignal, fetchUser)
+
+// 2. A defineLoader for SSR routes
+const userLoader = drizzleLoader(db, (db, ctx) =>
+  db.select().from(users).where(eq(users.id, Number(ctx.params.id))),
+)
+export const userRoute = defineRoute('/users/:id', handler, { loader: userLoader })
+```
+
+`drizzle-orm` and its drivers (`postgres`, `@libsql/client`) are **optional peer dependencies** referenced via `import type` only — importing this package never breaks when no Drizzle peer is installed. You supply the `db` handle; the adapter only awaits the query.
+<!-- END_HANDWRITTEN: prose -->
+
+## Install
+
+<!-- BEGIN_AUTOGEN: install -->
+<!-- regenerate: bun scripts/sync-readme.ts (also runs in pre-commit + CI) -->
+
+```bash
+npm install @aihu-plugin/drizzle
+# or
+bun add @aihu-plugin/drizzle
+```
+
+<sub><i>Auto-generated against `@aihu-plugin/drizzle@0.1.0`.</i></sub>
+
+<!-- END_AUTOGEN: install -->
+
+## Package facts
+
+<!-- BEGIN_AUTOGEN: stats -->
+<!-- regenerate: bun scripts/sync-readme.ts (also runs in pre-commit + CI) -->
+
+| | |
+|---|---|
+| **Version** | `0.1.0` |
+| **Tier** | E — Held private (unmapped tier) |
+| **Published files** | 3 entries |
+| **License** | MIT |
+
+<sub><i>Auto-generated against `@aihu-plugin/drizzle@0.1.0`.</i></sub>
+
+<!-- END_AUTOGEN: stats -->
+
+## Exports
+
+<!-- BEGIN_AUTOGEN: exports -->
+<!-- regenerate: bun scripts/sync-readme.ts (also runs in pre-commit + CI) -->
+
+| Subpath | ESM | CJS |
+|---|---|---|
+| `.` | `./dist/index.js` | `—` |
+
+<sub><i>Auto-generated against `@aihu-plugin/drizzle@0.1.0`.</i></sub>
+
+<!-- END_AUTOGEN: exports -->
+
+## Dependencies
+
+<!-- BEGIN_AUTOGEN: deps -->
+<!-- regenerate: bun scripts/sync-readme.ts (also runs in pre-commit + CI) -->
+
+**Dependencies:**
+
+- `@aihu/server` — `workspace:*`
+
+**Peer dependencies:**
+
+- `drizzle-orm` — `>=0.29.0`
+
+<sub><i>Auto-generated against `@aihu-plugin/drizzle@0.1.0`.</i></sub>
+
+<!-- END_AUTOGEN: deps -->
+
+## See also
+
+<!-- BEGIN_AUTOGEN: see-also -->
+<!-- regenerate: bun scripts/sync-readme.ts (also runs in pre-commit + CI) -->
+
+- [Aihu framework root](../../README.md)
+- [v1.1 roadmap](../../docs/roadmap/SUMMARY.md)
+
+<sub><i>Auto-generated against `@aihu-plugin/drizzle@0.1.0`.</i></sub>
+
+<!-- END_AUTOGEN: see-also -->
+
+## License
+
+<!-- BEGIN_AUTOGEN: license -->
+<!-- regenerate: bun scripts/sync-readme.ts (also runs in pre-commit + CI) -->
+
+MIT — see [LICENSE](../../LICENSE).
+
+<sub><i>Auto-generated against `@aihu-plugin/drizzle@0.1.0`.</i></sub>
+
+<!-- END_AUTOGEN: license -->

package/dist/index.d.ts

@@ -0,0 +1,121 @@
+import { DefinedLoader, RouteContext, defineLoader } from "@aihu/server";
+import { Plugin } from "@aihu/plugin";
+
+//#region src/types.d.ts
+/**
+ * @aihu-plugin/drizzle — shared types for the Drizzle ORM data adapter.
+ *
+ * Drizzle's own types (`drizzle-orm`, `postgres`, `@libsql/client`) are
+ * OPTIONAL peer dependencies. To keep this package importable when those peers
+ * are absent, we DO NOT statically import any `drizzle-orm` runtime value and
+ * we reference Drizzle types only through `import type` in the files that need
+ * them (see `query.ts`). The structural types below describe the minimal shape
+ * the adapter actually depends on, so consumers get useful typing whether or
+ * not `drizzle-orm` is installed.
+ */
+/**
+ * The minimal "thenable" shape Drizzle query builders satisfy. A Drizzle query
+ * (e.g. `db.select().from(users).where(...)`) is a `PromiseLike` that resolves
+ * to a row array; awaiting it executes the SQL. We accept any `PromiseLike<T>`
+ * so prepared statements, `.execute()` results, and raw promises all work.
+ */
+type DrizzleQuery<T> = PromiseLike<T>;
+/**
+ * A query factory: given a Drizzle database handle and a key, returns either a
+ * Drizzle query (PromiseLike) or a plain Promise of the result. This is the
+ * single user-supplied function both `createDrizzleResource` and
+ * `drizzleLoader` are built from.
+ *
+ * @typeParam DB  The Drizzle database handle type (kept generic — the adapter
+ *                never inspects it, so any of the pg / sqlite / libsql handles
+ *                fit without importing their concrete types).
+ * @typeParam K   The key type. For `createResource` fetchers this is the cache
+ *                key (a string); for loaders it is the loader context.
+ * @typeParam T   The resolved row/result type.
+ */
+type DrizzleQueryFn<DB, K, T> = (db: DB, key: K) => DrizzleQuery<T> | Promise<T>;
+/**
+ * Options accepted by `createDrizzleResource`.
+ */
+interface DrizzleResourceOptions {
+  /**
+   * Map the resolved key string into the typed key passed to the query fn.
+   * Defaults to identity (the raw cache-key string). Use this when your query
+   * needs a parsed value (e.g. `Number(key)`).
+   */
+  readonly parseKey?: (key: string) => unknown;
+}
+//#endregion
+//#region src/query.d.ts
+/**
+ * Build a `createResource`-compatible fetcher from a Drizzle query.
+ *
+ * The returned function has signature `(key: string) => Promise<T>` — exactly
+ * what `@aihu-plugin/data`'s `createResource(keySignal, fetcher, options?)`
+ * expects as its second argument.
+ *
+ * @param db       A Drizzle database handle (pg / sqlite / libsql). Kept fully
+ *                 generic; the adapter never inspects it.
+ * @param queryFn  `(db, key) => DrizzleQuery<T> | Promise<T>`. `key` is the
+ *                 parsed cache key (see `options.parseKey`; defaults to the raw
+ *                 string).
+ * @param options  `parseKey` to transform the string cache key before it hits
+ *                 the query (e.g. `Number`).
+ *
+ * @example
+ * import { drizzle } from 'drizzle-orm/libsql'
+ * import { eq } from 'drizzle-orm'
+ * import { createResource } from '@aihu-plugin/data'
+ * import { createDrizzleResource } from '@aihu-plugin/drizzle'
+ *
+ * const db = drizzle(client)
+ * const fetchUser = createDrizzleResource(
+ *   db,
+ *   (db, id: number) => db.select().from(users).where(eq(users.id, id)),
+ *   { parseKey: Number },
+ * )
+ * const user = createResource(idSignal, fetchUser)
+ */
+declare function createDrizzleResource<DB, K, T>(db: DB, queryFn: DrizzleQueryFn<DB, K, T>, options?: DrizzleResourceOptions): (key: string) => Promise<T>;
+/**
+ * Build a `defineLoader`-wrapped SSR loader from a Drizzle query.
+ *
+ * The query fn receives the Drizzle handle and the `@aihu/server` `RouteContext`
+ * (params, request, etc.), so loaders can read `ctx.params.id` directly. The
+ * result is a `DefinedLoader<T>` ready to pass to `defineRoute(..., { loader })`.
+ * Loader errors are caught by `@aihu/server`'s `runLoader` and surfaced as
+ * `ctx.loaderData.error` — this adapter does not swallow them.
+ *
+ * @example
+ * import { drizzle } from 'drizzle-orm/libsql'
+ * import { eq } from 'drizzle-orm'
+ * import { defineRoute } from '@aihu/server'
+ * import { drizzleLoader } from '@aihu-plugin/drizzle'
+ *
+ * const db = drizzle(client)
+ * const userLoader = drizzleLoader(db, (db, ctx) =>
+ *   db.select().from(users).where(eq(users.id, Number(ctx.params.id))),
+ * )
+ * export const userRoute = defineRoute('/users/:id', handler, { loader: userLoader })
+ */
+declare function drizzleLoader<DB, T>(db: DB, queryFn: DrizzleQueryFn<DB, RouteContext, T>): ReturnType<typeof defineLoader<T>>;
+//#endregion
+//#region src/index.d.ts
+/**
+ * Plugin factory for `@aihu-plugin/drizzle`. Accepts optional configuration
+ * (reserved for v0.4+ when query-macro lowering is wired) and returns the
+ * configured plugin instance for `defineAihuConfig({ plugins: [drizzle()] })`.
+ *
+ * @example
+ * // aihu.config.ts
+ * import { drizzle } from '@aihu-plugin/drizzle'
+ * import { defineAihuConfig } from '@aihu/server'
+ *
+ * export default defineAihuConfig({
+ *   plugins: [drizzle()],
+ * })
+ */
+declare function drizzle(_config?: Record<string, never>): Plugin;
+//#endregion
+export { type DefinedLoader, type DrizzleQuery, type DrizzleQueryFn, type DrizzleResourceOptions, createDrizzleResource, drizzle, drizzleLoader };
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","names":[],"sources":["../src/types.ts","../src/query.ts","../src/index.ts"],"mappings":";;;;;;;;AAkBA;;;;;;;;;AAeA;;;;KAfY,YAAA,MAAkB,WAAA,CAAY,CAAA;;;;;;;;;;;;;;KAe9B,cAAA,cAA4B,EAAA,EAAI,EAAA,EAAI,GAAA,EAAK,CAAA,KAAM,YAAA,CAAa,CAAA,IAAK,OAAA,CAAQ,CAAA;;;;UAKpE,sBAAA;EALqE;AAKtF;;;;EALsF,SAW3E,QAAA,IAAY,GAAA;AAAA;;;;;;;;;;;;;;AANvB;;;;;;;;ACmCA;;;;;;;;;;iBAAgB,qBAAA,UAAA,CACd,EAAA,EAAI,EAAA,EACJ,OAAA,EAAS,cAAA,CAAe,EAAA,EAAI,CAAA,EAAG,CAAA,GAC/B,OAAA,GAAU,sBAAA,IACR,GAAA,aAAgB,OAAA,CAAQ,CAAA;;;;;;;;;;;;;;;;;;;;AA6B5B;;iBAAgB,aAAA,OAAA,CACd,EAAA,EAAI,EAAA,EACJ,OAAA,EAAS,cAAA,CAAe,EAAA,EAAI,YAAA,EAAc,CAAA,IACzC,UAAA,QAAkB,YAAA,CAAa,CAAA;;;;;;;;;;;;ADvElC;;;;;iBEYgB,OAAA,CAAQ,OAAA,GAAU,MAAA,kBAAwB,MAAA"}

package/dist/index.js

@@ -0,0 +1,2 @@
+import{defineLoader as e}from"@aihu/server";async function t(e,t,n){return await Promise.resolve(t(e,n))}function n(e,n,r){let i=r?.parseKey;return r=>t(e,n,i?i(r):r)}function r(n,r){return e(e=>t(n,r,e))}const i={name:`drizzle`,version:`0.1.0`,namespace:`drizzle`,serverOnly:!0,contributes:{},__aihu_plugin:!0};function a(e){return i}export{n as createDrizzleResource,a as drizzle,r as drizzleLoader};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":[],"sources":["../src/query.ts","../src/plugin.ts","../src/index.ts"],"sourcesContent":["/**\n * @aihu-plugin/drizzle — query adapters.\n *\n * Turns a Drizzle query into the two data-access shapes aihu uses:\n *\n *   1. `createDrizzleResource(db, queryFn)` → a `(key: string) => Promise<T>`\n *      fetcher, drop-in for `@aihu-plugin/data`'s `createResource`.\n *   2. `drizzleLoader(db, queryFn)` → a `DefinedLoader<T>` for `@aihu/server`'s\n *      `defineLoader` (parallel SSR loaders).\n *\n * SERVER-ONLY. A Drizzle `db` handle holds a live DB connection, so these run\n * exclusively in the SSR / loader tier — never in a browser bundle. This\n * package therefore carries NO `.size-limit.json` row (see\n * `.size-limit.README.md`, server-side classification).\n *\n * Optional-peer discipline: `drizzle-orm` and its drivers (`postgres`,\n * `@libsql/client`) are OPTIONAL peerDependencies. This module imports NO\n * `drizzle-orm` runtime value and references Drizzle types only via\n * `import type`, so `import('@aihu-plugin/drizzle')` succeeds even when no\n * Drizzle package is installed. The user supplies the `db` handle and query\n * fn; we only `await` the result.\n */\n\n// Type-only re-exports of the structural Drizzle shapes. These erase at build\n// time (verbatimModuleSyntax), so nothing from `drizzle-orm` is required at\n// runtime — the optional-peer guarantee.\nimport type { LoaderFn, RouteContext } from '@aihu/server'\nimport { defineLoader } from '@aihu/server'\nimport type { DrizzleQueryFn, DrizzleResourceOptions } from './types.ts'\n\n// Re-export DefinedLoader so consumers do not need a direct @aihu/server import\n// just to type the return of drizzleLoader.\nexport type { DefinedLoader } from '@aihu/server'\n\n/**\n * Run a user query fn against a Drizzle handle and normalize the result to a\n * real `Promise<T>`. A Drizzle query builder is a `PromiseLike`, not a true\n * `Promise`, so we wrap it in `Promise.resolve(...)` to give callers a value\n * `createResource`'s `fetcher: (key) => Promise<T>` contract guarantees.\n */\nasync function runQuery<DB, K, T>(db: DB, queryFn: DrizzleQueryFn<DB, K, T>, key: K): Promise<T> {\n  return await Promise.resolve(queryFn(db, key))\n}\n\n/**\n * Build a `createResource`-compatible fetcher from a Drizzle query.\n *\n * The returned function has signature `(key: string) => Promise<T>` — exactly\n * what `@aihu-plugin/data`'s `createResource(keySignal, fetcher, options?)`\n * expects as its second argument.\n *\n * @param db       A Drizzle database handle (pg / sqlite / libsql). Kept fully\n *                 generic; the adapter never inspects it.\n * @param queryFn  `(db, key) => DrizzleQuery<T> | Promise<T>`. `key` is the\n *                 parsed cache key (see `options.parseKey`; defaults to the raw\n *                 string).\n * @param options  `parseKey` to transform the string cache key before it hits\n *                 the query (e.g. `Number`).\n *\n * @example\n * import { drizzle } from 'drizzle-orm/libsql'\n * import { eq } from 'drizzle-orm'\n * import { createResource } from '@aihu-plugin/data'\n * import { createDrizzleResource } from '@aihu-plugin/drizzle'\n *\n * const db = drizzle(client)\n * const fetchUser = createDrizzleResource(\n *   db,\n *   (db, id: number) => db.select().from(users).where(eq(users.id, id)),\n *   { parseKey: Number },\n * )\n * const user = createResource(idSignal, fetchUser)\n */\nexport function createDrizzleResource<DB, K, T>(\n  db: DB,\n  queryFn: DrizzleQueryFn<DB, K, T>,\n  options?: DrizzleResourceOptions,\n): (key: string) => Promise<T> {\n  const parseKey = options?.parseKey\n  return (key: string): Promise<T> => {\n    const typedKey = (parseKey ? parseKey(key) : key) as K\n    return runQuery(db, queryFn, typedKey)\n  }\n}\n\n/**\n * Build a `defineLoader`-wrapped SSR loader from a Drizzle query.\n *\n * The query fn receives the Drizzle handle and the `@aihu/server` `RouteContext`\n * (params, request, etc.), so loaders can read `ctx.params.id` directly. The\n * result is a `DefinedLoader<T>` ready to pass to `defineRoute(..., { loader })`.\n * Loader errors are caught by `@aihu/server`'s `runLoader` and surfaced as\n * `ctx.loaderData.error` — this adapter does not swallow them.\n *\n * @example\n * import { drizzle } from 'drizzle-orm/libsql'\n * import { eq } from 'drizzle-orm'\n * import { defineRoute } from '@aihu/server'\n * import { drizzleLoader } from '@aihu-plugin/drizzle'\n *\n * const db = drizzle(client)\n * const userLoader = drizzleLoader(db, (db, ctx) =>\n *   db.select().from(users).where(eq(users.id, Number(ctx.params.id))),\n * )\n * export const userRoute = defineRoute('/users/:id', handler, { loader: userLoader })\n */\nexport function drizzleLoader<DB, T>(\n  db: DB,\n  queryFn: DrizzleQueryFn<DB, RouteContext, T>,\n): ReturnType<typeof defineLoader<T>> {\n  const fn: LoaderFn<T> = (ctx: RouteContext) => runQuery(db, queryFn, ctx)\n  return defineLoader<T>(fn)\n}\n","import type { Plugin } from '@aihu/plugin'\n\n/**\n * `@aihu-plugin/drizzle` plugin — registration shim.\n *\n * Registers the Drizzle adapter under the Plugin Contract (Plugin Contract Spec\n * §1.1, §3, §7.1). Like `@aihu-plugin/data`, this ships registration plumbing\n * ONLY — `contributes: {}` is a deliberate no-op. The adapter's value lives in\n * the runtime helper library (`createDrizzleResource` / `drizzleLoader`), NOT in\n * macro lowering: the compiler's macro-lowering dispatcher is a no-op until\n * v0.4, so there is no `$resource`-style macro to wire here yet.\n *\n * `serverOnly: true` marks this plugin's (future) contributions as server-bundle\n * only — a Drizzle `db` handle holds a live DB connection and must never reach a\n * browser bundle (Plugin Contract Spec §6.5 / Amendment 03).\n *\n * We construct the Plugin object directly (satisfying the `Plugin` type contract\n * via `__aihu_plugin: true`) rather than calling `definePlugin()`, keeping\n * `@aihu/plugin` a build/type-only dependency with zero runtime footprint — same\n * pattern as `@aihu-plugin/data`'s `dataPlugin`.\n *\n * Consumers register it via:\n *   defineAihuConfig({ plugins: [drizzle()] })\n */\nexport const drizzlePlugin: Plugin = {\n  name: 'drizzle',\n  version: '0.1.0',\n  namespace: 'drizzle',\n  serverOnly: true,\n  contributes: {}, // no-op until v0.4 lowers query macros\n  __aihu_plugin: true,\n}\n","/**\n * @aihu-plugin/drizzle — Drizzle ORM data adapter for aihu.\n *\n * SERVER-ONLY. Produces typed data-access shapes from Drizzle queries:\n *\n *   createDrizzleResource(db, queryFn, options?) → (key: string) => Promise<T>\n *       A fetcher compatible with `@aihu-plugin/data`'s\n *       `createResource(keySignal, fetcher, options?)`.\n *\n *   drizzleLoader(db, queryFn) → DefinedLoader<T>\n *       An SSR loader for `@aihu/server`'s `defineLoader` / `defineRoute`.\n *\n * Plugin registration (Plugin Contract Spec §3, §7.1):\n *   drizzle() → Plugin — register in `defineAihuConfig({ plugins: [drizzle()] })`.\n *\n * Optional peers: `drizzle-orm` and its drivers (`postgres`, `@libsql/client`)\n * are OPTIONAL peerDependencies. This package imports NO `drizzle-orm` runtime\n * value (Drizzle types are referenced via `import type` only), so importing it\n * never breaks when the peers are absent. The caller supplies the `db` handle.\n *\n * NOT browser-eligible: a Drizzle `db` handle holds a live DB connection, so the\n * adapter runs only in the SSR / loader tier and carries NO `.size-limit.json`\n * row (see `.size-limit.README.md`, server-side classification).\n */\n\nexport type { DefinedLoader } from './query.ts'\nexport { createDrizzleResource, drizzleLoader } from './query.ts'\nexport type { DrizzleQuery, DrizzleQueryFn, DrizzleResourceOptions } from './types.ts'\n\n// ---------------------------------------------------------------------------\n// Plugin factory (Plugin Contract Spec §3)\n// ---------------------------------------------------------------------------\n\nimport type { Plugin } from '@aihu/plugin'\nimport { drizzlePlugin } from './plugin.ts'\n\n/**\n * Plugin factory for `@aihu-plugin/drizzle`. Accepts optional configuration\n * (reserved for v0.4+ when query-macro lowering is wired) and returns the\n * configured plugin instance for `defineAihuConfig({ plugins: [drizzle()] })`.\n *\n * @example\n * // aihu.config.ts\n * import { drizzle } from '@aihu-plugin/drizzle'\n * import { defineAihuConfig } from '@aihu/server'\n *\n * export default defineAihuConfig({\n *   plugins: [drizzle()],\n * })\n */\nexport function drizzle(_config?: Record<string, never>): Plugin {\n  return drizzlePlugin\n}\n"],"mappings":"4CAwCA,eAAe,EAAmB,EAAQ,EAAmC,EAAoB,CAC/F,OAAO,MAAM,QAAQ,QAAQ,EAAQ,EAAI,EAAI,CAAC,CAgChD,SAAgB,EACd,EACA,EACA,EAC6B,CAC7B,IAAM,EAAW,GAAS,SAC1B,MAAQ,IAEC,EAAS,EAAI,EADF,EAAW,EAAS,EAAI,CAAG,EACP,CAyB1C,SAAgB,EACd,EACA,EACoC,CAEpC,OAAO,EADkB,GAAsB,EAAS,EAAI,EAAS,EAAI,CAC/C,CCvF5B,MAAa,EAAwB,CACnC,KAAM,UACN,QAAS,QACT,UAAW,UACX,WAAY,GACZ,YAAa,EAAE,CACf,cAAe,GAChB,CCmBD,SAAgB,EAAQ,EAAyC,CAC/D,OAAO"}

package/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "@aihu-plugin/drizzle",
+  "version": "0.1.0",
+  "license": "MIT",
+  "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"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "sideEffects": false,
+  "scripts": {
+    "build": "rolldown -c",
+    "typecheck": "tsc --noEmit",
+    "prepublishOnly": "bun run build"
+  },
+  "dependencies": {
+    "@aihu/server": "0.2.0"
+  },
+  "devDependencies": {
+    "@aihu/plugin": "0.1.0",
+    "@aihu-plugin/data": "2.0.0"
+  },
+  "peerDependencies": {
+    "drizzle-orm": ">=0.29.0"
+  },
+  "peerDependenciesMeta": {
+    "drizzle-orm": {
+      "optional": true
+    }
+  },
+  "description": "Drizzle ORM data adapter for aihu — typed createResource fetchers and defineLoader helpers (Postgres / SQLite / libSQL).",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/fellwork/aihu.git",
+    "directory": "packages/plugin-drizzle"
+  },
+  "homepage": "https://github.com/fellwork/aihu/tree/main/packages/plugin-drizzle#readme",
+  "bugs": "https://github.com/fellwork/aihu/issues",
+  "publishConfig": {
+    "access": "public"
+  }
+}