@noxify/casl-drizzle 0.0.1-beta.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Guilherme Araújo
+
+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,107 @@
+> work in progress :)
+
+# casl-drizzle
+
+CASL integration for Drizzle ORM - Add type-safe authorization to your database queries
+
+## Install
+
+```sh
+npm install ucastle @casl/ability
+```
+
+## Quick Start
+
+Define your abilities using Drizzle's query types directly:
+
+```typescript
+import type { QueryInput } from "ucastle"
+import { integer, pgTable, text } from "drizzle-orm/pg-core"
+import { accessibleBy, defineAbility } from "ucastle"
+
+// Define your Drizzle schema
+const users = pgTable("users", {
+  id: integer().primaryKey(),
+  name: text().notNull(),
+  email: text().notNull(),
+})
+
+const schema = { users }
+
+// Extract query types for your tables
+type UserQuery = QueryInput<typeof schema, "users">
+
+// Create abilities with subject-specific autocomplete
+const ability = defineAbility<{ users: UserQuery }>((can, cannot) => {
+  can("read", "users", { id: 1 }) // ✅ Autocomplete shows only user fields!
+  can("update", "users", { id: 1 })
+  cannot("delete", "users")
+})
+
+// Use with accessibleBy to get database filters
+const filters = accessibleBy(ability, "read")
+const readableUsers = await db.query.users.findMany({ where: filters.users })
+```
+
+## Features
+
+- 🔒 **Type-safe authorization** - Full TypeScript support with Drizzle types
+- 🎯 **CASL integration** - Leverage CASL's powerful rule system
+- 🗄️ **DB agnostic** - Works with PostgreSQL, MySQL, SQLite, etc.
+- 🔗 **Relation support** - Filter by related table conditions
+- 📦 **Zero overhead** - Direct type composition, no runtime wrappers
+- 💡 **Smart autocomplete** - Subject-specific field suggestions with `defineAbility()`
+
+## With Relations
+
+For schemas with relations, use `RelationalQueryInput`:
+
+```typescript
+import type { RelationalQueryInput } from "ucastle"
+import { defineRelations } from "drizzle-orm"
+
+const posts = pgTable("posts", {
+  id: integer().primaryKey(),
+  title: text().notNull(),
+  authorId: integer().notNull(),
+})
+
+const relations = defineRelations({ users, posts }, (r) => ({
+  users: { posts: r.many(posts) },
+  posts: { author: r.one(users, { fields: [posts.authorId], references: [users.id] }) },
+}))
+
+type PostQuery = RelationalQueryInput<typeof relations, "posts">
+
+const ability = defineAbility<{ posts: PostQuery }>((can) => {
+  can("read", "posts", { published: true })
+  can("update", "posts", { authorId: 1 })
+})
+```
+
+## Alternative: AbilityBuilder
+
+If you prefer the traditional AbilityBuilder pattern:
+
+```typescript
+import type { DefineAbility } from "ucastle"
+import { AbilityBuilder } from "@casl/ability"
+import { createDrizzleAbilityFor } from "ucastle"
+
+type AppAbility = DefineAbility<{ users: UserQuery }>
+
+const { can, cannot, build } = new AbilityBuilder<AppAbility>(createDrizzleAbilityFor())
+
+can("read", "users", { id: 1 })
+cannot("delete", "users")
+
+const ability = build()
+```
+
+## Documentation
+
+See [SIMPLIFIED_API.md](./SIMPLIFIED_API.md) for detailed examples and patterns.
+
+## License
+
+MIT

package/dist/index.d.mts

@@ -0,0 +1,214 @@
+import { AbilityOptions, AbilityOptionsOf, AbilityTuple, AnyAbility, ForcedSubject, PureAbility, RawRuleFrom, RawRuleOf, hkt } from "@casl/ability";
+import * as _ucast_core0 from "@ucast/core";
+import { DBQueryConfig, SchemaEntry, TablesRelationalConfig } from "drizzle-orm/relations";
+import { KnownKeysOnly } from "drizzle-orm/utils";
+
+//#region src/drizzle-query.d.ts
+declare const drizzleQuery: (query: Record<string, unknown>, ...args: unknown[]) => {
+  (...args: any[]): any;
+  ast: _ucast_core0.Condition;
+};
+type Model<T, TName extends string> = T & ForcedSubject<TName>;
+type Subjects<T extends Partial<Record<string, Record<string, unknown>>>> = keyof T | { [K in keyof T]: Model<T[K], K & string> }[keyof T];
+/**
+ * Extracts Drizzle model name from given object and possible list of all subjects
+ */
+type ExtractModelName<TObject, TModelName extends PropertyKey> = TObject extends {
+  kind: TModelName;
+} ? TObject["kind"] : TObject extends ForcedSubject<TModelName> ? TObject["__caslSubjectType__"] : TObject extends {
+  __typename: TModelName;
+} ? TObject["__typename"] : TModelName;
+//#endregion
+//#region src/types.d.ts
+interface BaseDrizzleQuery {
+  [ɵdrizzleTypes]?: Record<string, unknown>;
+}
+declare const ɵdrizzleTypes: unique symbol;
+type DrizzleQueryFactory = Record<string, unknown> & hkt.Container<hkt.GenericFactory> & BaseDrizzleQuery;
+type DrizzleModel = Model<Record<string, unknown>, string>;
+type WhereInput = Record<string, unknown>;
+/**
+ * Utility type to recursively remove the RAW property from Drizzle query types.
+ * RAW is used internally by Drizzle for SQL functions but shouldn't be exposed in our API.
+ */
+type OmitRaw<T> = T extends object ? { [K in keyof T as K extends "RAW" ? never : K]: T[K] extends object ? T[K] extends any[] ? OmitRaw<T[K][number]>[] : OmitRaw<T[K]> : T[K] } : T;
+/**
+ * Query input for tables WITH relations.
+ * Extracts the complete where type including relation filters from Drizzle's DBQueryConfig.
+ *
+ * @example
+ * ```ts
+ * import { defineRelations } from "drizzle-orm"
+ * import type { RelationalQueryInput } from "ucastle"
+ *
+ * const relations = defineRelations({ users, posts }, ...)
+ * type UserQuery = RelationalQueryInput<typeof relations, "users">
+ *
+ * // Now includes: field conditions + relation filters + AND/OR/NOT
+ * ```
+ */
+type RelationalQueryInput<TSchema extends TablesRelationalConfig, TTableName extends keyof TSchema> = OmitRaw<Exclude<KnownKeysOnly<DBQueryConfig<"many", TSchema, TSchema[TTableName]>, DBQueryConfig<"many", TSchema, TSchema[TTableName]>>["where"], undefined>>;
+/**
+ * Query input for tables WITHOUT relations.
+ * Supports both field conditions and compound operators (AND/OR/NOT) at root level.
+ *
+ * @example
+ * ```ts
+ * import type { QueryInput } from "ucastle"
+ *
+ * const schema = { users, posts }
+ * type UserQuery = QueryInput<typeof schema, "users">
+ *
+ * // Field conditions
+ * const q1: UserQuery = { id: 1, name: "John" }
+ *
+ * // With operators
+ * const q2: UserQuery = { id: { gte: 1 }, AND: [{ name: "John" }] }
+ *
+ * // Compound operators
+ * const q3: UserQuery = { OR: [{ age: 18 }, { role: "admin" }] }
+ * ```
+ */
+type QueryInput<TSchema extends Record<string, SchemaEntry>, TTableName extends keyof TSchema> = OmitRaw<{ [K in keyof (TSchema[TTableName] extends {
+  $inferSelect: infer S;
+} ? S : never)]?: any } & {
+  AND?: QueryInput<TSchema, TTableName>[];
+  OR?: QueryInput<TSchema, TTableName>[];
+  NOT?: QueryInput<TSchema, TTableName>;
+}>;
+/**
+ * Helper type to create CASL subjects from a mapping of table names to query types.
+ * Similar to @casl/prisma's Subjects pattern.
+ *
+ * @example
+ * ```ts
+ * import { PureAbility } from "@casl/ability"
+ * import type { RelationalQueryInput, Subjects } from "ucastle"
+ *
+ * type UserQuery = RelationalQueryInput<typeof relations, "users">
+ * type PostQuery = RelationalQueryInput<typeof relations, "posts">
+ *
+ * type AppAbility = PureAbility<[string, Subjects<{
+ *   users: UserQuery,
+ *   posts: PostQuery
+ * }>]>
+ * ```
+ */
+type Subjects$1<T> = { [K in keyof T]: Model<T[K], K & string> }[keyof T] | Extract<keyof T, string>;
+/**
+ * Custom Ability type with subject-specific conditions.
+ * Similar to @casl/prisma's PrismaAbility.
+ *
+ * This type ensures that conditions are properly typed based on the subject mapping.
+ *
+ * @example
+ * ```ts
+ * import type { DrizzleAbility } from "ucastle"
+ *
+ * type SubjectMap = {
+ *   users: UserQuery
+ *   posts: PostQuery
+ * }
+ *
+ * type AppAbility = DrizzleAbility<SubjectMap>
+ * ```
+ */
+type DrizzleAbility$1<T> = PureAbility<[string, Subjects$1<T>], T[keyof T]>;
+/**
+ * Helper type to create a fully-typed DrizzleAbility from a subject mapping.
+ * Provides subject-specific autocomplete in `can()` and `cannot()` methods
+ * when used with `defineAbility()`.
+ * Works with both `type` and `interface`.
+ *
+ * @example
+ * ```ts
+ * import { defineAbility, type DefineAbility } from "ucastle"
+ *
+ * // Works with type
+ * type SubjectMap = {
+ *   users: UserQuery
+ *   posts: PostQuery
+ * }
+ *
+ * // Also works with interface
+ * interface SubjectMap {
+ *   users: UserQuery
+ *   posts: PostQuery
+ * }
+ *
+ * // Use with defineAbility for subject-specific autocomplete:
+ * const ability = defineAbility<SubjectMap>((can, cannot) => {
+ *   can("read", "users", { id: 1 }) // ✅ Only user fields!
+ *   can("read", "posts", { authorId: 1 }) // ✅ Only post fields!
+ * })
+ * ```
+ */
+type DefineAbility<T> = DrizzleAbility$1<T>;
+//#endregion
+//#region src/factories/accessible-by.d.ts
+/**
+ * @deprecated use accessibleBy directly instead. It will infer the types from passed Ability instance.
+ */
+declare const createAccessibleByFactory: <TResult extends Record<string, unknown>, TDrizzleQuery>() => <TAbility extends PureAbility<any, TDrizzleQuery>>(ability: TAbility, action?: TAbility["rules"][number]["action"]) => TResult;
+declare function accessibleBy<TAbility extends PureAbility<any, any>>(ability: TAbility, action?: TAbility["rules"][number]["action"]): Record<string, WhereInput>;
+//#endregion
+//#region src/factories/create-ability.d.ts
+declare function createAbilityFactory<TModelName extends string, TDrizzleQuery extends Record<string, any>>(): {
+  <T extends PureAbility<any, TDrizzleQuery>>(rules?: RawRuleOf<T>[], options?: AbilityOptionsOf<T>): T;
+  <A extends AbilityTuple = [string, TModelName], C extends TDrizzleQuery = TDrizzleQuery>(rules?: RawRuleFrom<A, C>[], options?: AbilityOptions<A, C>): PureAbility<A, C>;
+};
+//#endregion
+//#region src/query-error.d.ts
+declare class ParsingQueryError extends Error {
+  static invalidArgument(operatorName: string, value: unknown, expectValueType: string): ParsingQueryError;
+}
+//#endregion
+//#region src/index.d.ts
+/**
+ * Factory function to create a DrizzleAbility instance.
+ * Use with AbilityBuilder for type-safe ability definitions.
+ *
+ * @example
+ * ```ts
+ * import { AbilityBuilder } from "@casl/ability"
+ * import { createDrizzleAbilityFor, type DefineAbility } from "ucastle"
+ *
+ * type AppAbility = DefineAbility<{
+ *   users: UserQuery
+ *   posts: PostQuery
+ * }>
+ *
+ * const { can, build } = new AbilityBuilder<AppAbility>(createDrizzleAbilityFor())
+ * ```
+ */
+declare function createDrizzleAbilityFor(): new (...args: ConstructorParameters<typeof PureAbility>) => AnyAbility;
+/**
+ * Create a type-safe ability with subject-specific conditions.
+ * This provides better autocomplete than using AbilityBuilder directly.
+ *
+ * @example
+ * ```ts
+ * import { defineAbility } from "ucastle"
+ *
+ * const ability = defineAbility<{
+ *   users: UserQuery
+ *   posts: PostQuery
+ * }>((can, cannot) => {
+ *   can("read", "users", { id: 1 }) // ✅ Only user fields
+ *   can("read", "posts", { authorId: 1 }) // ✅ Only post fields
+ * })
+ * ```
+ */
+declare function defineAbility<T>(define: (can: <S extends keyof T & string>(action: string, subject: S, conditions?: T[S]) => void, cannot: <S extends keyof T & string>(action: string, subject: S, conditions?: T[S]) => void) => void): PureAbility<[string, any], T[keyof T]>;
+/**
+ * Uses conditional type to support union distribution
+ */
+type ExtendedAbilityTuple<T extends AbilityTuple> = T extends AbilityTuple ? [T[0], "all" | T[1]] : never;
+/**
+ * @deprecated use createDrizzleAbilityFor instead
+ */
+declare class DrizzleAbility<A extends AbilityTuple = [string, string], C extends Record<string, unknown> = Record<string, unknown>> extends PureAbility<ExtendedAbilityTuple<A>, C> {
+  constructor(rules?: RawRuleFrom<ExtendedAbilityTuple<A>, C>[], options?: AbilityOptions<ExtendedAbilityTuple<A>, C>);
+}
+//#endregion
+export { type BaseDrizzleQuery, type DefineAbility, DrizzleAbility, type DrizzleModel, type DrizzleQueryFactory, type Subjects as DrizzleSubjects, type ExtractModelName, type Model, ParsingQueryError, type QueryInput, type RelationalQueryInput, type Subjects$1 as Subjects, type WhereInput, accessibleBy, createAbilityFactory, createAccessibleByFactory, createDrizzleAbilityFor, defineAbility, drizzleQuery };

package/dist/index.mjs

@@ -0,0 +1 @@
+import{AbilityBuilder as e,ForbiddenError as t,PureAbility as n,fieldPatternMatcher as r}from"@casl/ability";import{CompoundCondition as i,FieldCondition as a,NULL_CONDITION as o,ObjectQueryParser as s,buildAnd as c,createTranslatorFactory as l}from"@ucast/core";import{and as u,compare as d,createJsInterpreter as f,eq as p,gt as m,gte as h,lt as ee,lte as te,ne as g,or as _,within as v}from"@ucast/js";import{rulesToQuery as y}from"@casl/ability/extra";const b=(e,t,{get:n})=>n(t,e.field).startsWith(e.value),x=(e,t,{get:n})=>n(t,e.field).toLowerCase().startsWith(e.value.toLowerCase()),ne=(e,t,{get:n})=>n(t,e.field).endsWith(e.value),S=(e,t,{get:n})=>n(t,e.field).toLowerCase().endsWith(e.value.toLowerCase()),C=(e,t,{get:n})=>n(t,e.field).includes(e.value),w=(e,t,{get:n})=>n(t,e.field).toLowerCase().includes(e.value.toLowerCase()),T=(e,t,{get:n})=>{let r=n(t,e.field);return(Array.isArray(r)&&r.length===0)===e.value},E=(e,t,{get:n})=>{let r=n(t,e.field);return Array.isArray(r)&&r.includes(e.value)},D=(e,t,{get:n})=>{let r=n(t,e.field);return Array.isArray(r)&&e.value.some(e=>r.includes(e))},O=(e,t,{get:n})=>{let r=n(t,e.field);return Array.isArray(r)&&e.value.every(e=>r.includes(e))},k=(e,t,{get:n,interpret:r})=>{let i=n(t,e.field);return Array.isArray(i)&&i.length>0&&i.every(t=>r(e.value,t))},A=(e,t,{get:n,interpret:r})=>{let i=n(t,e.field);return Array.isArray(i)&&i.some(t=>r(e.value,t))},j=(e,t,{get:n,interpret:r})=>{let i=n(t,e.field);return typeof i==`object`&&!!i&&r(e.value,i)},M=(e,t,{interpret:n})=>e.value.every(e=>!n(e,t)),N=(e,t,{get:n})=>n(t,e.field)!==void 0;function P(e){return e&&typeof e==`object`?e.valueOf():e}const F=f({equals:p,notEquals:g,in:v,lt:ee,lte:te,gt:m,gte:h,startsWith:b,istartsWith:x,endsWith:ne,iendsWith:S,contains:C,icontains:w,isEmpty:T,has:E,hasSome:D,hasEvery:O,and:u,or:_,AND:u,OR:_,NOT:M,every:k,some:A,is:j,isSet:N},{get:(e,t)=>e[t],compare:(e,t)=>d(P(e),P(t))});var I=class extends Error{static invalidArgument(e,t,n){let r=`${typeof t}(${JSON.stringify(t,null,2)})`;return new this(`"${e}" expects to receive ${n} but instead got "${r}"`)}};const L=e=>typeof e==`object`&&!!e&&(Object.getPrototypeOf(e)===Object.prototype||Object.getPrototypeOf(e)===null),re={type:`field`,validate(e,t){if(Array.isArray(t)||L(t))throw new I(`"${e.name}" does not supports comparison of arrays and objects`)}},R={type:`field`,parse:((e,t,{hasOperators:n,field:r,parse:o})=>{if(L(t)&&!n(t)||Array.isArray(t))throw new I(`"${e.name}" does not supports comparison of arrays and objects`);return L(t)?new i(`NOT`,[o(t,{field:r})]):new a(`notEquals`,r,t)})},z={type:`field`,validate(e,t){if(!Array.isArray(t))throw I.invalidArgument(e.name,t,`an array`)}},B={type:`field`,validate(e,t){let n=typeof t;if(!(n===`string`||n===`number`&&Number.isFinite(t)||t instanceof Date))throw I.invalidArgument(e.name,t,`comparable value`)}},V=new Set([`insensitive`,`default`]),H={type:`field`,validate(e,t){if(!V.has(t))throw I.invalidArgument(e.name,t,`one of ${Array.from(V).join(`, `)}`)},parse:()=>o},U={type:`field`,validate(e,t){if(typeof t!=`string`)throw I.invalidArgument(e.name,t,`string`)},parse(e,t,{query:n,field:r}){return new a(n.mode===`insensitive`?`i${e.name}`:e.name,r,t)}},W={type:`compound`,validate(e,t){if(!t||typeof t!=`object`)throw I.invalidArgument(e.name,t,`an array or object`)},parse(e,t,{parse:n}){let r=(Array.isArray(t)?t:[t]).map(e=>n(e));return new i(e.name,r)}},G={type:`field`,validate(e,t){if(typeof t!=`boolean`)throw I.invalidArgument(e.name,t,`a boolean`)}},K={type:`field`},q={type:`field`,validate(e,t){if(!Array.isArray(t))throw I.invalidArgument(e.name,t,`an array`)}},J={type:`field`,parse(e,t,{field:n,parse:r}){if(!L(t))throw I.invalidArgument(e.name,t,`a query for nested relation`);return new a(e.name,n,r(t))}},Y=(e,t)=>{let n=t.parse?.bind(t);return n?{...t,parse(t,r,a){let o=n(t,r,a);if(o.operator!==t.name)throw Error(`Cannot invert "${e}" operator parser because it returns a complex Condition`);return o.operator=e,new i(`NOT`,[o])}}:{...t,parse(t,n,r){return new i(`NOT`,[new a(e,r.field,n)])}}},X={equals:re,not:R,in:z,notIn:Y(`in`,z),lt:B,lte:B,gt:B,gte:B,$lt:B,$lte:B,$gt:B,$gte:B,$in:z,$nin:Y(`in`,z),mode:H,startsWith:U,endsWith:U,contains:U,isEmpty:G,has:K,hasSome:q,hasEvery:q,NOT:W,AND:W,OR:W,every:J,some:J,none:Y(`some`,J),is:J,isNot:Y(`is`,J),isSet:G},Z=l(new class extends s{constructor(){super(X,{defaultOperatorName:`equals`})}parse(e,t){return t?.field?c(this.parseFieldOperators(t.field,e)):super.parse(e)}}().parse,F);function Q(e){if(typeof e!=`object`||!e)return e;if(Array.isArray(e))return e.map(Q);let t={};for(let[n,r]of Object.entries(e)){if(n===`OR`||n===`AND`){t[n]=Q(r);continue}if(n.startsWith(`$`)){let e=n.substring(1);t[e]=Q(r);continue}typeof r==`object`&&r&&!Array.isArray(r)?t[n]=Q(r):t[n]=r}return t}const ie={get(e,n){let r=y(e._ability,e._action,n,e=>e.inverted?{NOT:e.conditions}:e.conditions);if(r===null){let r=t.from(e._ability).setMessage(`It's not allowed to run "${e._action}" on "${n}"`);throw r.action=e._action,r.subjectType=r.subject=n,r}let i=Object.create(null);if(r.$or&&Array.isArray(r.$or)&&r.$or.length===1){let e=r.$or[0];Object.assign(i,e)}else r.$or&&(i.OR=r.$or);return r.$and&&(i.AND=r.$and),Q(i)}};function ae(e,t=`read`){return new Proxy({_ability:e,_action:t},ie)}function $(){function e(e=[],t={}){return new n(e,{...t,conditionsMatcher:Z,fieldMatcher:r})}return e}function oe(){return $()}function se(t){let n=new e($());return t((e,t,r)=>n.can(e,t,r),(e,t,r)=>n.cannot(e,t,r)),n.build()}var ce=class extends n{constructor(e,t){super(e,{conditionsMatcher:Z,fieldMatcher:r,...t})}};export{ce as DrizzleAbility,I as ParsingQueryError,ae as accessibleBy,oe as createDrizzleAbilityFor,se as defineAbility,Z as drizzleQuery};

package/package.json

@@ -0,0 +1,91 @@
+{
+  "name": "@noxify/casl-drizzle",
+  "version": "0.0.1-beta.0",
+  "description": "Drizzle-ORM adapter for CASL - generate Drizzle where inputs from CASL abilities",
+  "keywords": [
+    "drizzle",
+    "drizzle-orm",
+    "casl",
+    "ucast"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/noxify/casl-drizzle"
+  },
+  "license": "MIT",
+  "authors": [
+    {
+      "name": "Marcus Reinhardt",
+      "email": "webstone@gmail.com"
+    },
+    {
+      "name": "Guilherme Araújo",
+      "email": "arauujogui@gmail.com"
+    }
+  ],
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.mts",
+      "import": "./dist/index.mjs",
+      "default": "./src/index.ts"
+    }
+  },
+  "types": "./dist/index.d.mts",
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "@ucast/core": "^1.10.2",
+    "@ucast/js": "3.1.0"
+  },
+  "prettier": "./prettier.config.mjs",
+  "devDependencies": {
+    "@casl/ability": "^6.8.0",
+    "@changesets/cli": "2.29.8",
+    "@eslint/compat": "2.0.2",
+    "@eslint/js": "9.39.2",
+    "@ianvs/prettier-plugin-sort-imports": "4.7.1",
+    "@testcontainers/postgresql": "^11.11.0",
+    "@types/js-yaml": "4.0.9",
+    "@types/node": "24.10.13",
+    "@vitest/coverage-v8": "4.0.18",
+    "dedent": "1.7.1",
+    "drizzle-kit": "beta",
+    "drizzle-orm": "beta",
+    "eslint": "9.39.2",
+    "eslint-plugin-import": "2.32.0",
+    "eslint-plugin-package-json": "0.88.2",
+    "json-schema-to-typescript": "15.0.4",
+    "jsonc-eslint-parser": "2.4.2",
+    "node-pty": "1.1.0",
+    "postgres": "3.4.8",
+    "prettier": "3.8.1",
+    "tsdown": "0.20.3",
+    "tsx": "4.21.0",
+    "typescript": "^5.9.3",
+    "typescript-eslint": "8.55.0",
+    "vitest": "4.0.18"
+  },
+  "peerDependencies": {
+    "@casl/ability": "^6.8.0",
+    "drizzle-orm": ">=1.0.0-beta.15"
+  },
+  "engines": {
+    "node": ">=22"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "ci:publish": "pnpm build && pnpm publish -r --access public --publish-branch main && pnpm changeset tag",
+    "ci:version": "pnpm changeset version && pnpm install --no-frozen-lockfile && git add .",
+    "cs": "changeset",
+    "format": "prettier --check . --ignore-path ./.gitignore --ignore-path ./.prettierignore",
+    "format:fix": "prettier --write . --ignore-path ./.gitignore --ignore-path ./.prettierignore",
+    "lint": "eslint .",
+    "lint:fix": "eslint . --fix",
+    "test": "vitest --run",
+    "test:coverage": "vitest --coverage",
+    "test:watch": "vitest",
+    "typecheck": "tsc --noEmit"
+  }
+}