@quark-fw/entity 0.1.26 → 0.1.28

package/README.md

@@ -18,6 +18,12 @@ import { createEntity } from "@quark-fw/entity";
 export const taskEntity = createEntity({
 	model: "task",                        // key of your EntityModels augmentation
 	defaultSort: { field: "createdAt", dir: "desc" },
+	// scope beyond the owner: a where fragment from the context (team, org); the
+	// client cannot set these fields, create() stamps them
+	scope: (ctx) => ({ orgId: ctx.user.orgId }),
+	// allowlists for the client: other columns are server-side only (methods)
+	writable: ["title", "done"],            // create / update / controller.update
+	filterable: ["title", "done", "createdAt"], // list/count where keys and sort field
 	methods: {
 		// custom method: plain function or { input: zodSchema, handler }
 		complete: { input: z.object({ id: z.string() }), handler: ({ id }) => /* ... */ },

package/dist/client/createEntityContext.d.ts

@@ -3,7 +3,7 @@ import type { Serialize } from "@quark-fw/store/src/serialize.js";
 import type { EntitiesContextType, EntityContextType } from "./types.js";
 export declare function createEntityContext<TRow extends {
     id: string;
-}>(entityKey: string): readonly [({ children, filter, limit, sort, }: {
+}>(entityKey: string): readonly [({ children, filter, limit, sort, live, }: {
     children: ReactNode;
     /** серверный фильтр списка (общий для всех потребителей) */
     filter?: Record<string, unknown>;
@@ -12,6 +12,12 @@ export declare function createEntityContext<TRow extends {
         field: string;
         dir?: "asc" | "desc";
     };
+    /**
+     * Живые обновления: подписка на изменения сущности (SSE) и
+     * перечитывание списка при каждом событии — правки других
+     * пользователей и вкладок появляются без перезагрузки.
+     */
+    live?: boolean;
 }) => import("react/jsx-runtime").JSX.Element, ({ children, id, }: {
     children: ReactNode;
     id: string;

package/dist/client/createEntityContext.js

@@ -5,6 +5,7 @@ import { jsx as _jsx } from "react/jsx-runtime";
 // ВАЖНО: клиентский модуль — не импортировать серверный ../index.js.
 import { createContext, startTransition, useEffect, useMemo, useRef, useState, } from "react";
 import { useStore, useTrpc } from "@quark-fw/store";
+import { subscribeChanges } from "./subscribeChanges.js";
 import { reportError } from "@quark-fw/store/src/errors.js";
 import { useEntityForm } from "../useEntityForm.js";
 import { uuidv7 } from "../uuidv7.js";
@@ -14,7 +15,7 @@ export function createEntityContext(entityKey) {
     const EntityContext = createContext(null);
     const useEntities = useSafeContext(`${entityKey} entities context was not found in tree`, EntitiesContext);
     const useEntity = useSafeContext(`${entityKey} entity context was not found in tree`, EntityContext);
-    const EntitiesProvider = ({ children, filter, limit = 100, sort, }) => {
+    const EntitiesProvider = ({ children, filter, limit = 100, sort, live = false, }) => {
         const store = useStore();
         // Имя сущности приходит параметром, поэтому ветку роутера нельзя
         // вывести статически — но набор процедур у всех сущностей общий и
@@ -262,6 +263,49 @@ export function createEntityContext(entityKey) {
             // рендер, а сам пишет состояние — с ним эффект зациклится
             // eslint-disable-next-line react-hooks/exhaustive-deps
         }, [fresh]);
+        // live: по событию перечитываем список и счётчик по сети и кладём в
+        // состояние тем же путём, что и серверные данные. Пачка событий
+        // (перестановка карточек) схлопывается в один запрос; собственная
+        // мутация в полёте важнее — перечитаем после неё.
+        useEffect(() => {
+            if (!live)
+                return;
+            let timer;
+            let cancelled = false;
+            const refresh = async () => {
+                if (cancelled || loadedPages.current > 1)
+                    return;
+                if (mutationsInFlight.current > 0) {
+                    timer = setTimeout(() => void refresh(), 300);
+                    return;
+                }
+                try {
+                    const [list, total] = await Promise.all([
+                        trpcCaller.list.mutate(serverArgs),
+                        trpcCaller.count.mutate(countArgs),
+                    ]);
+                    if (cancelled)
+                        return;
+                    setList(list);
+                    tinyCaller.count.setCache(countArgs)(total);
+                }
+                catch (error) {
+                    reportError(error, entityKey);
+                }
+            };
+            const off = subscribeChanges(entityKey, (handlers) => trpcCaller.changes.subscribe(undefined, handlers), () => {
+                clearTimeout(timer);
+                timer = setTimeout(() => void refresh(), 150);
+            }, (error) => reportError(error, entityKey));
+            return () => {
+                cancelled = true;
+                clearTimeout(timer);
+                off();
+            };
+            // setList/trpcCaller пересоздаются каждый рендер — зависим от
+            // ключа аргументов, как эффект синхронизации выше
+            // eslint-disable-next-line react-hooks/exhaustive-deps
+        }, [live, argsKey]);
         const rows = completeList ?? fresh;
         const value = {
             list: ({ filter: extraFilter } = {}) => [

package/dist/client/subscribeChanges.d.ts

@@ -0,0 +1,15 @@
+import type { EntityChange } from "../types.js";
+type Subscription = {
+    unsubscribe(): void;
+};
+type Subscribe = (handlers: {
+    onData: (change: EntityChange) => void;
+    onError?: (error: unknown) => void;
+}) => Subscription;
+/**
+ * Подписка на изменения сущности, разделяемая всеми провайдерами с тем же
+ * ключом. Возвращает функцию отписки; соединение закрывается, когда отписался
+ * последний.
+ */
+export declare function subscribeChanges(key: string, subscribe: Subscribe, listener: (change: EntityChange) => void, onError: (error: unknown) => void): () => void;
+export {};

package/dist/client/subscribeChanges.js

@@ -0,0 +1,29 @@
+// одна SSE-подписка на сущность на вкладку: провайдеров одной сущности на
+// странице много (колонка доски — провайдер), а браузер держит к хосту лишь
+// шесть HTTP/1.1-соединений; по подписке на провайдер доска их исчерпала бы
+const shared = new Map();
+/**
+ * Подписка на изменения сущности, разделяемая всеми провайдерами с тем же
+ * ключом. Возвращает функцию отписки; соединение закрывается, когда отписался
+ * последний.
+ */
+export function subscribeChanges(key, subscribe, listener, onError) {
+    let entry = shared.get(key);
+    if (!entry) {
+        const listeners = new Set();
+        const subscription = subscribe({
+            onData: (change) => listeners.forEach((l) => l(change)),
+            onError,
+        });
+        entry = { subscription, listeners };
+        shared.set(key, entry);
+    }
+    entry.listeners.add(listener);
+    return () => {
+        entry.listeners.delete(listener);
+        if (entry.listeners.size === 0) {
+            entry.subscription.unsubscribe();
+            shared.delete(key);
+        }
+    };
+}

package/dist/client/types.d.ts

@@ -1,4 +1,5 @@
 import type { useEntityForm } from "../useEntityForm.js";
+import type { EntityChange } from "../types.js";
 export type EntitiesListParams = {
     /**
      * Фильтр КОНКРЕТНОГО потребителя (например колонки доски). Применяется
@@ -49,6 +50,11 @@ export type EntityTrpcCaller<Row> = {
     list: {
         mutate(args: EntityListArgs): Promise<Row[]>;
     };
+    count: {
+        mutate(args: {
+            where?: Record<string, unknown>;
+        }): Promise<number>;
+    };
     create: {
         mutate(args: {
             data: Record<string, unknown>;
@@ -72,6 +78,15 @@ export type EntityTrpcCaller<Row> = {
             data?: unknown;
         }): Promise<unknown>;
     };
+    /** SSE-поток изменений сущности (см. live у EntitiesProvider) */
+    changes: {
+        subscribe(input: undefined, handlers: {
+            onData: (change: EntityChange) => void;
+            onError?: (error: unknown) => void;
+        }): {
+            unsubscribe(): void;
+        };
+    };
 };
 export type TinyBranch<Row> = {
     entity: Record<string, EntityTinyCaller<Row>>;

package/dist/client.d.ts

@@ -1,2 +1,3 @@
 export { createEntityContext } from "./client/createEntityContext.js";
 export type { EntitiesContextType, EntitiesListParams, EntityContextType, EntityListArgs, EntityTinyCaller, EntityTrpcCaller, } from "./client/types.js";
+export type { EntityChange } from "./types.js";

package/dist/createEntity.d.ts

@@ -1,6 +1,6 @@
 import { z, ZodType } from "zod";
 import { publicProcedure, type TRPCContext } from "@quark-fw/plugin-trpc/src/trpc.js";
-import type { EntityField, EntityModelName, EntityRow } from "./types.js";
+import type { EntityChange, EntityField, EntityModelName, EntityRow } from "./types.js";
 export type CustomMethodFn = (input?: unknown) => unknown;
 export type CustomMethodValidated<TSchema extends ZodType = ZodType> = {
     input: TSchema;
@@ -79,12 +79,26 @@ export type EntityRelation<TModel extends string = EntityModelName> = {
         /** колонка родителя, с которой сопоставляется ссылка (по умолчанию id) */
         parentField?: EntityField<TParent>;
         /** колонка владельца на родителе, например "userId" */
-        authField: EntityField<TParent>;
+        authField?: EntityField<TParent>;
+        /** либо произвольный скоуп родителя (см. scope у createEntity) */
+        scope?: EntityScope;
     };
 }[EntityModelName];
+/**
+ * where-фрагмент, ограничивающий видимость и запись для вызывающего:
+ * { orgId: ctx.user.orgId }, { teamId: await teamOf(ctx) }. Только равенства:
+ * тот же фрагмент дописывается в create, чтобы запись сразу попала в скоуп.
+ */
+export type EntityScope = (ctx: TRPCContext) => Record<string, unknown> | Promise<Record<string, unknown>>;
 export type CreateEntityArgs<TModel extends EntityModelName> = {
     model: TModel;
     authField?: EntityField<TModel>;
+    /**
+     * Произвольный скоуп поверх (или вместо) владельца: команда, организация,
+     * роль. Применяется ко всем процедурам роутера как и authField; поля
+     * скоупа клиент задавать не может — они берутся из контекста.
+     */
+    scope?: EntityScope;
     procedure?: EntityProcedure;
     defaultSort?: {
         field: EntityField<TModel>;
@@ -98,6 +112,18 @@ export type CreateEntityArgs<TModel extends EntityModelName> = {
      * сразу по нескольким колонкам выражается только отдельными запросами.
      */
     searchField?: EntityField<TModel>;
+    /**
+     * Поля, которые клиент вправе задавать в create/update. Без списка
+     * принимается любая колонка — клиент пишет и в служебные поля (массовое
+     * присваивание). Колонка владельца и id отсекаются в любом случае.
+     */
+    writable?: EntityField<TModel>[];
+    /**
+     * Поля, по которым клиент вправе фильтровать (where) и сортировать (sort)
+     * в list/count. Без списка — любая колонка, в том числе та, что наружу не
+     * отдаётся: сортировкой по ней значение подбирается посимвольно.
+     */
+    filterable?: EntityField<TModel>[];
     relations?: EntityRelation<TModel>[];
     extendMethods?: (args: {
         model: EntityModelHandle;
@@ -143,7 +169,7 @@ export declare function createEntity<TModel extends EntityModelName>(args: Creat
     createRouter: () => import("@trpc/server").TRPCBuiltRouter<{
         ctx: TRPCContext;
         meta: object;
-        errorShape: import("@trpc/server").TRPCDefaultErrorShape;
+        errorShape: import("@quark-fw/plugin-trpc/src/errorFormatter.js").ErrorShape;
         transformer: false;
     }, import("@trpc/server").TRPCDecorateCreateRouterOptions<{
         list: import("@trpc/server").TRPCMutationProcedure<{
@@ -195,6 +221,11 @@ export declare function createEntity<TModel extends EntityModelName>(args: Creat
             output: {};
             meta: object;
         }>;
+        changes: import("@trpc/server").TRPCSubscriptionProcedure<{
+            input: void;
+            output: AsyncIterable<EntityChange, void, any>;
+            meta: object;
+        }>;
         count: import("@trpc/server").TRPCMutationProcedure<{
             input: {
                 where?: Record<string, any> | undefined;

package/dist/createEntity.js

@@ -1,6 +1,7 @@
 import { TRPCError } from "@trpc/server";
 import { z } from "zod";
 import { publicProcedure, router, } from "@quark-fw/plugin-trpc/src/trpc.js";
+import { subscribeEvent } from "@quark-fw/plugin-trpc/src/subscribeEvent.js";
 import { invoke, modelByName } from "./helpers.js";
 // Сериализуемая сортировка: orderBy в Prisma 8 принимает СЕЛЕКТОР-функцию
 // (f) => f.field.asc(), поэтому по сети передаём {field, dir}, а функцию
@@ -87,6 +88,22 @@ export function createEntity(args) {
         ...baseController(row),
         ...(args.extendController?.({ entity: row }) ?? {}),
     });
+    // Событие после записи: на нём держатся подписки клиента (changes) и
+    // любая серверная реакция; через plugin-threads уходит во все инстансы.
+    // Владелец в событии — чтобы подписка не раздавала чужие изменения.
+    const emitChange = (op, row) => {
+        if (row && typeof row === "object" && "id" in row) {
+            const r = row;
+            const owner = args.authField ? r[args.authField] : undefined;
+            quark.ee.value.emit("entity:changed", {
+                model: args.model,
+                op,
+                id: String(r.id),
+                ...(typeof owner === "string" ? { owner } : {}),
+            });
+        }
+        return row;
+    };
     const withController = (row) => {
         if (!row || typeof row !== "object")
             return row;
@@ -104,8 +121,8 @@ export function createEntity(args) {
         getById: async (id) => withController((await chain({ id }).first())),
         /** как getById, но по произвольному where (используется для скоупинга) */
         getOne: async (where) => withController((await chain(where).first())),
-        create: async (data) => withController((await getModel().create(data))),
-        update: async (id, data) => withController((await chain({ id }).update(data))),
+        create: async (data) => withController(emitChange("create", (await getModel().create(data)))),
+        update: async (id, data) => withController(emitChange("update", (await chain({ id }).update(data)))),
         // Prisma 8 при непопадании во where возвращает null, а не бросает.
         // Молчаливый null скрыл бы и опечатку в id, и попытку тронуть чужую
         // запись — отвечаем NOT_FOUND (существование чужой не подтверждаем).
@@ -117,9 +134,9 @@ export function createEntity(args) {
                     message: `${args.model} not found`,
                 });
             }
-            return withController(row);
+            return withController(emitChange("update", row));
         },
-        deleteById: (id) => chain({ id }).delete(),
+        deleteById: async (id) => emitChange("delete", await chain({ id }).delete()),
         deleteWhere: async (where) => {
             const row = await chain(where).delete();
             if (!row) {
@@ -128,7 +145,7 @@ export function createEntity(args) {
                     message: `${args.model} not found`,
                 });
             }
-            return row;
+            return emitChange("delete", row);
         },
         // count() билдера доступен только внутри include-рефайнментов —
         // счёт делается через aggregate
@@ -153,8 +170,12 @@ export function createEntity(args) {
                 throw new TRPCError({ code: "UNAUTHORIZED" });
             return id;
         };
-        // where-скоуп владельца: {} если authField не задан
-        const scope = (ctx) => args.authField ? { [args.authField]: ownerId(ctx) } : {};
+        // where-скоуп вызывающего: владелец (authField) и/или произвольный
+        // фрагмент из scope; {} если не задано ничего
+        const scope = async (ctx) => ({
+            ...(args.authField ? { [args.authField]: ownerId(ctx) } : {}),
+            ...(args.scope ? await args.scope(ctx) : {}),
+        });
         /**
          * Убирает из присланных данных поля, которые клиент задавать не вправе.
          *
@@ -174,6 +195,26 @@ export function createEntity(args) {
                 delete clean[field];
             return clean;
         };
+        // Поля вне списка — ошибкой, а не молчаливым отсевом: отсев скрыл бы
+        // опечатку в клиенте так же, как и попытку записать лишнее
+        const assertFields = (keys, allowed, kind) => {
+            if (!allowed)
+                return;
+            for (const key of keys) {
+                if (!allowed.includes(key)) {
+                    throw new TRPCError({
+                        code: "BAD_REQUEST",
+                        message: `Field "${key}" of ${args.model} is not ${kind}`,
+                    });
+                }
+            }
+        };
+        const assertFilter = (input) => {
+            assertFields(Object.keys(input?.where ?? {}), args.filterable, "filterable");
+            if (input?.sort) {
+                assertFields([input.sort.field], args.filterable, "filterable");
+            }
+        };
         // порт checkRelation: записать ссылку на родителя можно, только если
         // этот родитель принадлежит вызывающему (иначе чужой id «подсунули»)
         const checkRelations = async (data, ctx) => {
@@ -184,7 +225,10 @@ export function createEntity(args) {
                 const parent = await modelByName(relation.model)
                     .where({
                     [relation.parentField ?? "id"]: value,
-                    [relation.authField]: ownerId(ctx),
+                    ...(relation.authField
+                        ? { [relation.authField]: ownerId(ctx) }
+                        : {}),
+                    ...(relation.scope ? await relation.scope(ctx) : {}),
                 })
                     .first();
                 if (!parent) {
@@ -204,10 +248,14 @@ export function createEntity(args) {
          * и переписывал владельца записи.
          */
         const updateFromClient = async (id, input, ctx) => {
-            const data = stripProtected(input, ["id"]);
+            const current = await scope(ctx);
+            // поля скоупа тоже защищены: иначе запись переносится в чужую
+            // команду/организацию так же, как раньше — к чужому владельцу
+            const data = stripProtected(input, ["id", ...Object.keys(current)]);
+            assertFields(Object.keys(data), args.writable, "writable");
             await checkRelations(data, ctx);
             // скоуп во where: чужую запись обновить нельзя
-            const where = { id, ...scope(ctx) };
+            const where = { id, ...current };
             // после отсева могло не остаться ни одного поля —
             // отвечаем самой записью, а не ложным NOT_FOUND
             if (!Object.keys(data).length) {
@@ -235,19 +283,29 @@ export function createEntity(args) {
         ]));
         return router({
             ...customProcedures,
-            list: proc.input(listSchema.optional()).mutation(({ input, ctx }) => methods.list({
-                ...(input ?? {}),
-                where: { ...(input?.where ?? {}), ...scope(ctx) },
-            })),
+            list: proc
+                .input(listSchema.optional())
+                .mutation(async ({ input, ctx }) => {
+                assertFilter(input);
+                return methods.list({
+                    ...(input ?? {}),
+                    where: {
+                        ...(input?.where ?? {}),
+                        ...(await scope(ctx)),
+                    },
+                });
+            }),
             getById: proc
                 .input(z.string())
-                .mutation(({ input, ctx }) => methods.getOne({ id: input, ...scope(ctx) })),
+                .mutation(async ({ input, ctx }) => methods.getOne({ id: input, ...(await scope(ctx)) })),
             create: proc
                 .input(z.object({ data: z.record(z.string(), z.any()) }))
                 .mutation(async ({ input, ctx }) => {
-                const data = stripProtected(input.data);
+                const current = await scope(ctx);
+                const data = stripProtected(input.data, Object.keys(current));
+                assertFields(Object.keys(data), args.writable, "writable");
                 await checkRelations(data, ctx);
-                return methods.create({ ...data, ...scope(ctx) });
+                return methods.create({ ...data, ...current });
             }),
             update: proc
                 .input(z.object({
@@ -257,14 +315,47 @@ export function createEntity(args) {
                 .mutation(({ input, ctx }) => updateFromClient(input.id, input.data, ctx)),
             delete: proc
                 .input(z.object({ id: z.string() }))
-                .mutation(({ input, ctx }) => methods.deleteWhere({ id: input.id, ...scope(ctx) })),
+                .mutation(async ({ input, ctx }) => methods.deleteWhere({
+                id: input.id,
+                ...(await scope(ctx)),
+            })),
+            // Поток изменений этой сущности для клиента (SSE). Скоуп тот же,
+            // что у list: с authField уходят только изменения строк владельца.
+            // Произвольный scope проверяется запросом за строкой (владелец
+            // событий известен, скоуп — нет); удаление проверить нечем — оно
+            // уходит всем подписчикам модели, в нём только id.
+            changes: proc.subscription(async function* ({ ctx, signal }) {
+                const owner = args.authField ? ownerId(ctx) : undefined;
+                const current = args.scope ? await args.scope(ctx) : undefined;
+                for await (const [change] of subscribeEvent("entity:changed", signal)) {
+                    if (change.model !== args.model)
+                        continue;
+                    if (owner !== undefined && change.owner !== owner)
+                        continue;
+                    if (current && change.op !== "delete") {
+                        const row = await methods.getOne({
+                            id: change.id,
+                            ...current,
+                        });
+                        if (!row)
+                            continue;
+                    }
+                    yield change;
+                }
+            }),
             count: proc
                 .input(z
                 .object({
                 where: z.record(z.string(), z.any()).optional(),
             })
                 .optional())
-                .mutation(({ input, ctx }) => methods.count({ ...(input?.where ?? {}), ...scope(ctx) })),
+                .mutation(async ({ input, ctx }) => {
+                assertFilter(input);
+                return methods.count({
+                    ...(input?.where ?? {}),
+                    ...(await scope(ctx)),
+                });
+            }),
             controller: proc
                 .input(z.object({
                 id: z.string(),
@@ -274,7 +365,7 @@ export function createEntity(args) {
                 .mutation(async ({ input, ctx }) => {
                 const row = (await chain({
                     id: input.id,
-                    ...scope(ctx),
+                    ...(await scope(ctx)),
                 }).first());
                 if (!row)
                     throw new TRPCError({ code: "NOT_FOUND" });

package/dist/global.d.ts

@@ -1,3 +1,11 @@
 import "@quark-fw/core/src/global.js";
+import type { EntityChange } from "./types.js";
 
 export {};
+
+declare global {
+	interface Events {
+		/** строка сущности создана/изменена/удалена через её методы */
+		"entity:changed": [EntityChange];
+	}
+}

package/dist/helpers.js

@@ -11,7 +11,7 @@ export const ormModels = () => {
     const { db } = quark;
     const models = db?.orm?.public;
     if (!models) {
-        throw new Error("@quark-fw/entity: quark.db.orm.public недоступен — не подключён @quark/plugin-prisma?");
+        throw new Error("@quark-fw/entity: quark.db.orm.public недоступен — не подключён @quark-fw/plugin-prisma?");
     }
     return models;
 };

package/dist/index.d.ts

@@ -1,2 +1,3 @@
-export type { EntityModels, EntityModelName, EntityRow, EntityField, } from "./types.js";
-export { createEntity, sortSchema, type CreateEntityArgs, type CustomMethod, type CustomMethodFn, type CustomMethodValidated, type EntityModelHandle, type EntityProcedure, type EntityRelation, type EntitySort, } from "./createEntity.js";
+/// <reference path="global.d.ts" />
+export type { EntityModels, EntityModelName, EntityRow, EntityField, EntityChange, } from "./types.js";
+export { createEntity, sortSchema, type CreateEntityArgs, type CustomMethod, type CustomMethodFn, type CustomMethodValidated, type EntityModelHandle, type EntityProcedure, type EntityRelation, type EntityScope, type EntitySort, } from "./createEntity.js";

package/dist/types.d.ts

@@ -30,4 +30,12 @@ export type EntityModelName = ModelsDeclared extends true ? keyof EntityModels &
 export type EntityRow<TModel extends string> = TModel extends keyof EntityModels ? EntityModels[TModel] : Record<string, unknown>;
 /** имя колонки модели */
 export type EntityField<TModel extends string> = TModel extends keyof EntityModels ? keyof EntityModels[TModel] & string : string;
+/** событие entity:changed — после create/update/delete через методы сущности */
+export type EntityChange = {
+    model: string;
+    op: "create" | "update" | "delete";
+    id: string;
+    /** значение колонки владельца (authField), если она задана */
+    owner?: string;
+};
 export {};

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@quark-fw/entity",
-	"version": "0.1.26",
+	"version": "0.1.28",
 	"description": "Entity CRUD layer over tRPC and Prisma for the Quark framework",
 	"type": "module",
 	"main": "dist/index.js",
@@ -19,7 +19,7 @@
 	],
 	"scripts": {
 		"dev": "tsx watch src/index.ts",
-		"build": "tsc -p tsconfig.build.json && node ../../scripts/postbuild.mjs",
+		"build": "node ../../node_modules/tsgo/bin/tsc -p tsconfig.build.json && node ../../scripts/postbuild.mjs",
 		"test": "vitest run"
 	},
 	"keywords": [
@@ -31,13 +31,13 @@
 		"access": "public"
 	},
 	"dependencies": {
-		"@quark-fw/plugin-trpc": "0.1.26",
-		"@quark-fw/store": "0.1.26",
+		"@quark-fw/plugin-trpc": "0.1.28",
+		"@quark-fw/store": "0.1.28",
 		"@trpc/server": "^11.0.0",
 		"zod": "^4.0.0"
 	},
 	"peerDependencies": {
-		"@quark-fw/core": "0.1.26",
+		"@quark-fw/core": "0.1.28",
 		"react": "^19.2.4"
 	},
 	"devDependencies": {