@ordinatio/entities 1.1.0 → 1.3.0

package/README.md

@@ -193,7 +193,7 @@ await app.entities.createNote({ entityType: 'client', entityId: 'client-123', co
 
 ### Tags Module (`@ordinatio/entities/tags`, experimental)
 
-Pure, zero-dependency helpers for tags, on their own subpath so a browser component can import them without pulling in the rest of the package (no Prisma, zod or Node modules): `tagNameKey` / `cleanTagName` / `checkTagName` (the case-insensitive identity of a name; **pinned to its first shipped behaviour** because apps store the key in a unique column), `TAG_COLORS` / `isTagColor` / `resolveTagColor`, `DEFAULT_TAG_LIMITS` (name length 40, 50 changes per save, 15 pinned, 500 per workspace: defaults, a store takes them as arguments), and the picker helpers `describeTagChanges`, `tagSetKey`, `rebaseSelection`, `mergeTagOptions`. The `./schemas` and `./errors` subpaths exist only in the workspace (source) exports map and are not part of the published package yet. A store interface, service and contract suite are planned for a later release on a separate server entry; until a second product has used them, the interface is experimental.
+Pure, zero-dependency helpers for tags, on their own subpath so a browser component can import them without pulling in the rest of the package (no Prisma, zod or Node modules): `tagNameKey` / `cleanTagName` / `checkTagName` (the case-insensitive identity of a name; **pinned to its first shipped behaviour** because apps store the key in a unique column), `TAG_COLORS` / `isTagColor` / `resolveTagColor`, `DEFAULT_TAG_LIMITS` (name length 40, 50 changes per save, 15 pinned, 500 per workspace: defaults, a store takes them as arguments), and the picker helpers `describeTagChanges`, `tagSetKey`, `rebaseSelection`, `mergeTagOptions`. The `./schemas` and `./errors` subpaths exist only in the workspace (source) exports map and are not part of the published package yet. On the separate server entry `@ordinatio/entities/tags/server` (EXPERIMENTAL until a second product has used it): the `TagStore` interface (built per workspace, so the package never sees a tenant id; atomic, typed, limit-aware operations), `createTagService(store, limits?)` (the tag rules over any store: validate and clean names and colours, create and find-or-create, rename/recolour/pin, remove, apply only the changes a user made to one item's tags, and read tags back sorted; every outcome a user can cause is a typed `{ ok: false, reason, ... }` result with the context an app needs for its message, and a store result it does not know throws; a store that throws is not caught, so an app that must never fail a page, such as a sidebar of pinned tags, wraps that one call itself; `pinned()` asks the store for the first `maxPinned` pinned tags, so make `listPinned` return them in a stable order such as by name), `planTagChanges`, an in-memory reference store (`createMemoryTagWorld`, `createMemoryTagHarness`) and the store contract suite `defineTagStoreContract` that any storage adapter must pass (framework-agnostic: pass your runner's `describe`/`it`/`expect`). On a further entry, `@ordinatio/entities/tags/prisma` (also EXPERIMENTAL): `createPrismaTagStore(config)`, a ready-made `TagStore` for a Prisma client on Postgres, so an app writes configuration instead of storage code. It holds the generic storage rules: a per-workspace advisory lock around the two limits (the lock key prefix is configurable, so an app can keep an older key), lock waits that THROW on timeout in create, pin and update (a remove and a link write start no explicit lock of their own, so they wait only on locks other transactions hold, bounded only if those transactions are), `FOR UPDATE` on the tag row in an update (which briefly serialises with the key-share lock a concurrent link insert takes on the same tag), `createManyAndReturn` and `DELETE ... RETURNING` so `added` and `removed` come from rows really written, and foreign-key-abort handling (a link to a tag or item deleted a moment ago becomes `tagGone` or `targetGone`, decided by a fresh read after the aborted transaction). The configuration names your client (as a getter, called each time the store needs the client), the tag model and table, the workspace column, and per taggable kind the join model, table and columns and the item model; every name that reaches SQL is checked once and double-quoted, values are always bound. It needs Prisma 5.14 or later and unique and foreign-key constraints in your database (listed at the top of its `types.ts`) and does not import `@prisma/client`. **Prove it on YOUR database** by running `defineTagStoreContract` against it with a harness of your own (with at least ten connections available): the contract, not the unit tests of this package, is what shows the SQL, the locks and the foreign keys behave. Pin this package's exact version while the server entry is experimental: adding a required store method or a contract rule can break an adapter that passed before. The concurrency tests are meaningful only against a real store: run them against your database with a connection pool of at least 10. **Adapters and mappers must treat an unknown result `kind` or reason as an error**, never as success: adding a kind is a breaking change for an exhaustive switch.
 
 ### Contacts Module
 

package/dist/chunk-KPZRBM5J.mjs

@@ -0,0 +1,67 @@
+// src/tags/constants.ts
+var TAG_COLORS = ["neutral", "red", "amber", "green", "blue", "purple", "pink"];
+var DEFAULT_TAG_LIMITS = Object.freeze({
+  maxNameLength: 40,
+  maxChangesPerSave: 50,
+  maxPinned: 15,
+  maxPerWorkspace: 500
+});
+
+// src/tags/name.ts
+function cleanTagName(name) {
+  return name.trim().replace(/\s+/g, " ");
+}
+function tagNameKey(name) {
+  return cleanTagName(name).toLowerCase();
+}
+function checkTagName(name, maxLength = DEFAULT_TAG_LIMITS.maxNameLength) {
+  const cleaned = cleanTagName(name);
+  if (cleaned.length < 1) return { ok: false, reason: "empty", length: cleaned.length };
+  if (cleaned.length > maxLength) return { ok: false, reason: "too-long", length: cleaned.length };
+  return { ok: true, name: cleaned, key: tagNameKey(cleaned) };
+}
+function isTagColor(value) {
+  return typeof value === "string" && TAG_COLORS.includes(value);
+}
+function resolveTagColor(color) {
+  if (color === void 0) return { ok: true, color: "neutral" };
+  return isTagColor(color) ? { ok: true, color } : { ok: false };
+}
+
+// src/tags/changes.ts
+function describeTagChanges(before, after) {
+  return [
+    before.name !== after.name ? `renamed "${before.name}" to "${after.name}"` : "",
+    before.color !== after.color ? `changed its color to ${after.color}` : "",
+    before.pinned !== after.pinned ? after.pinned ? "pinned it to Bookmarks" : "unpinned it from Bookmarks" : ""
+  ].filter(Boolean);
+}
+function tagSetKey(ids) {
+  return [...new Set(ids)].sort().join(",");
+}
+function rebaseSelection(args) {
+  const initial = new Set(args.initial);
+  const selected = new Set(args.selected);
+  const userAdded = [...selected].filter((t) => !initial.has(t));
+  const userRemoved = new Set([...initial].filter((t) => !selected.has(t)));
+  const next = new Set([...args.server, ...userAdded].filter((t) => !userRemoved.has(t)));
+  return { initial: [...new Set(args.server)], selected: [...next] };
+}
+function mergeTagOptions(fresh, createdHere) {
+  const freshIds = new Set(fresh.map((t) => t.id));
+  return [...fresh, ...createdHere.filter((t) => !freshIds.has(t.id))].sort((a, b) => a.name.localeCompare(b.name));
+}
+
+export {
+  TAG_COLORS,
+  DEFAULT_TAG_LIMITS,
+  cleanTagName,
+  tagNameKey,
+  checkTagName,
+  isTagColor,
+  resolveTagColor,
+  describeTagChanges,
+  tagSetKey,
+  rebaseSelection,
+  mergeTagOptions
+};

package/dist/constants-DSRJ-l7Z.d.mts

@@ -0,0 +1,15 @@
+declare const TAG_COLORS: readonly ["neutral", "red", "amber", "green", "blue", "purple", "pink"];
+type TagColor = (typeof TAG_COLORS)[number];
+interface TagLimits {
+    /** Longest tag name, in characters, after cleaning. */
+    maxNameLength: number;
+    /** Upper bound on how many tags one save may add or remove: stops a crafted request sending thousands of ids into an IN query. */
+    maxChangesPerSave: number;
+    /** How many tags may be pinned (shown as bookmarks): pinning more is refused rather than silently ignored. */
+    maxPinned: number;
+    /** Per-workspace ceiling: forms load every tag, so an unbounded vocabulary would slow every form. */
+    maxPerWorkspace: number;
+}
+declare const DEFAULT_TAG_LIMITS: Readonly<TagLimits>;
+
+export { DEFAULT_TAG_LIMITS as D, type TagColor as T, TAG_COLORS as a, type TagLimits as b };

package/dist/tags/index.d.mts

@@ -1,16 +1,5 @@
-declare const TAG_COLORS: readonly ["neutral", "red", "amber", "green", "blue", "purple", "pink"];
-type TagColor = (typeof TAG_COLORS)[number];
-interface TagLimits {
-    /** Longest tag name, in characters, after cleaning. */
-    maxNameLength: number;
-    /** Upper bound on how many tags one save may add or remove: stops a crafted request sending thousands of ids into an IN query. */
-    maxChangesPerSave: number;
-    /** How many tags may be pinned (shown as bookmarks): pinning more is refused rather than silently ignored. */
-    maxPinned: number;
-    /** Per-workspace ceiling: forms load every tag, so an unbounded vocabulary would slow every form. */
-    maxPerWorkspace: number;
-}
-declare const DEFAULT_TAG_LIMITS: Readonly<TagLimits>;
+import { T as TagColor } from '../constants-DSRJ-l7Z.mjs';
+export { D as DEFAULT_TAG_LIMITS, a as TAG_COLORS, b as TagLimits } from '../constants-DSRJ-l7Z.mjs';
 
 /** Trims and collapses every run of whitespace (including tabs and no-break spaces) to one plain space. */
 declare function cleanTagName(name: string): string;
@@ -75,4 +64,4 @@ interface TagChoice {
  */
 declare function mergeTagOptions<T extends TagChoice>(fresh: readonly T[], createdHere: readonly T[]): T[];
 
-export { DEFAULT_TAG_LIMITS, type RebasedSelection, TAG_COLORS, type TagChoice, type TagColor, type TagLimits, type TagNameCheck, type TagSnapshot, checkTagName, cleanTagName, describeTagChanges, isTagColor, mergeTagOptions, rebaseSelection, resolveTagColor, tagNameKey, tagSetKey };
+export { type RebasedSelection, type TagChoice, TagColor, type TagNameCheck, type TagSnapshot, checkTagName, cleanTagName, describeTagChanges, isTagColor, mergeTagOptions, rebaseSelection, resolveTagColor, tagNameKey, tagSetKey };

package/dist/tags/index.mjs

@@ -1,56 +1,16 @@
-// src/tags/constants.ts
-var TAG_COLORS = ["neutral", "red", "amber", "green", "blue", "purple", "pink"];
-var DEFAULT_TAG_LIMITS = Object.freeze({
-  maxNameLength: 40,
-  maxChangesPerSave: 50,
-  maxPinned: 15,
-  maxPerWorkspace: 500
-});
-
-// src/tags/name.ts
-function cleanTagName(name) {
-  return name.trim().replace(/\s+/g, " ");
-}
-function tagNameKey(name) {
-  return cleanTagName(name).toLowerCase();
-}
-function checkTagName(name, maxLength = DEFAULT_TAG_LIMITS.maxNameLength) {
-  const cleaned = cleanTagName(name);
-  if (cleaned.length < 1) return { ok: false, reason: "empty", length: cleaned.length };
-  if (cleaned.length > maxLength) return { ok: false, reason: "too-long", length: cleaned.length };
-  return { ok: true, name: cleaned, key: tagNameKey(cleaned) };
-}
-function isTagColor(value) {
-  return typeof value === "string" && TAG_COLORS.includes(value);
-}
-function resolveTagColor(color) {
-  if (color === void 0) return { ok: true, color: "neutral" };
-  return isTagColor(color) ? { ok: true, color } : { ok: false };
-}
-
-// src/tags/changes.ts
-function describeTagChanges(before, after) {
-  return [
-    before.name !== after.name ? `renamed "${before.name}" to "${after.name}"` : "",
-    before.color !== after.color ? `changed its color to ${after.color}` : "",
-    before.pinned !== after.pinned ? after.pinned ? "pinned it to Bookmarks" : "unpinned it from Bookmarks" : ""
-  ].filter(Boolean);
-}
-function tagSetKey(ids) {
-  return [...new Set(ids)].sort().join(",");
-}
-function rebaseSelection(args) {
-  const initial = new Set(args.initial);
-  const selected = new Set(args.selected);
-  const userAdded = [...selected].filter((t) => !initial.has(t));
-  const userRemoved = new Set([...initial].filter((t) => !selected.has(t)));
-  const next = new Set([...args.server, ...userAdded].filter((t) => !userRemoved.has(t)));
-  return { initial: [...new Set(args.server)], selected: [...next] };
-}
-function mergeTagOptions(fresh, createdHere) {
-  const freshIds = new Set(fresh.map((t) => t.id));
-  return [...fresh, ...createdHere.filter((t) => !freshIds.has(t.id))].sort((a, b) => a.name.localeCompare(b.name));
-}
+import {
+  DEFAULT_TAG_LIMITS,
+  TAG_COLORS,
+  checkTagName,
+  cleanTagName,
+  describeTagChanges,
+  isTagColor,
+  mergeTagOptions,
+  rebaseSelection,
+  resolveTagColor,
+  tagNameKey,
+  tagSetKey
+} from "../chunk-KPZRBM5J.mjs";
 export {
   DEFAULT_TAG_LIMITS,
   TAG_COLORS,

package/dist/tags/prisma/index.d.mts

@@ -0,0 +1,60 @@
+import { T as TagRecord, a as TagStore } from '../../types-C81I1Teg.mjs';
+
+/** One taggable kind (a person, a task, a message ...). Names are Prisma model delegates, SQL tables and columns of YOUR schema. */
+interface PrismaTagTarget {
+    /** Prisma delegate of the join model, e.g. `contactTag`. */
+    linkModel: string;
+    /** SQL table of the join model, e.g. `ContactTag` (used in the one raw `DELETE ... RETURNING`). */
+    linkTable: string;
+    /** Column AND Prisma field on the join model that points at the item, e.g. `contactId`. */
+    targetColumn: string;
+    /** Prisma delegate of the item model, e.g. `contact`. */
+    targetModel: string;
+    /** The item model's workspace column. Defaults to the tag's. */
+    targetWorkspaceColumn?: string;
+}
+interface PrismaTagStoreConfig<Target extends string> {
+    /** Called each time the store needs the client (never at import), so a test can swap in a client with a bigger pool. */
+    client: () => PrismaLikeClient;
+    /** The workspace (organization, account, tenant) this store is built for. Every query is scoped by it. */
+    workspaceId: string;
+    /** Prisma delegate of the tag model, e.g. `tag`. */
+    tagModel: string;
+    /** SQL table of the tag model, e.g. `Tag` (used in the `SELECT ... FOR UPDATE`). */
+    tagTable: string;
+    /** Workspace column on the tag model, e.g. `organizationId`. */
+    workspaceColumn: string;
+    targets: Record<Target, PrismaTagTarget>;
+    /** Relation field on a join model to the tag. Default `tag`. */
+    tagRelation?: string;
+    /** Column AND field on a join model for the tag id. Default `tagId`. */
+    tagIdColumn?: string;
+    /** Column AND field on a join model for who tagged it. Default `addedBy`. */
+    addedByColumn?: string;
+    /** The advisory lock is on `prefix + workspaceId` (hashed by Postgres). Default `tags:`. Keep an old app's value so old and new servers serialise. */
+    lockKeyPrefix?: string;
+    /** How long a transaction waits for any one lock before it throws (Postgres lock_timeout). Default 5000. */
+    lockWaitMs?: number;
+    /** Interactive transaction limits. Defaults: maxWait 10000, timeout 15000. */
+    transaction?: {
+        maxWait?: number;
+        timeout?: number;
+    };
+    /** TEST ONLY: runs inside `applyLinks` after the existence reads and before the write, holding NO row lock, so a test can delete a tag or item there. */
+    onBeforeLinkWrite?: () => Promise<void>;
+}
+/** The part of a transaction client the store uses. A real Prisma transaction client satisfies it; model delegates are looked up by name. */
+interface PrismaLikeTx {
+    $executeRawUnsafe(query: string, ...values: unknown[]): Promise<unknown>;
+    $queryRawUnsafe(query: string, ...values: unknown[]): Promise<unknown>;
+}
+interface PrismaLikeClient extends PrismaLikeTx {
+    $transaction<R>(fn: (tx: PrismaLikeTx) => Promise<R>, options?: {
+        maxWait?: number;
+        timeout?: number;
+    }): Promise<R>;
+}
+
+declare function createPrismaTagStore<T extends TagRecord = TagRecord, Target extends string = string>(config: PrismaTagStoreConfig<Target>): TagStore<T, Target>;
+
+export { type PrismaLikeClient, type PrismaLikeTx, type PrismaTagStoreConfig, type PrismaTagTarget, createPrismaTagStore };

package/dist/tags/prisma/index.mjs

@@ -0,0 +1,268 @@
+// src/tags/prisma/identifiers.ts
+var IDENTIFIER = /^[A-Za-z_][A-Za-z0-9_]*$/;
+var RESERVED = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype", "toString", "valueOf", "hasOwnProperty"]);
+function assertIdentifier(value, what) {
+  if (typeof value !== "string" || !IDENTIFIER.test(value) || RESERVED.has(value)) {
+    throw new Error(`createPrismaTagStore: ${what} must be a plain identifier (letters, digits and underscores, not starting with a digit), got ${JSON.stringify(value)}`);
+  }
+  return value;
+}
+function quote(identifier) {
+  return `"${identifier}"`;
+}
+
+// src/tags/prisma/context.ts
+function resolveTarget(kind, target, defaultWorkspaceColumn) {
+  const where = `targets.${kind}`;
+  return {
+    linkModel: assertIdentifier(target.linkModel, `${where}.linkModel`),
+    linkTable: assertIdentifier(target.linkTable, `${where}.linkTable`),
+    targetColumn: assertIdentifier(target.targetColumn, `${where}.targetColumn`),
+    targetModel: assertIdentifier(target.targetModel, `${where}.targetModel`),
+    targetWorkspaceColumn: assertIdentifier(target.targetWorkspaceColumn ?? defaultWorkspaceColumn, `${where}.targetWorkspaceColumn`)
+  };
+}
+function createContext(config) {
+  if (typeof config.client !== "function") throw new Error("createPrismaTagStore: client must be a function that returns the Prisma client");
+  if (typeof config.workspaceId !== "string" || config.workspaceId === "") throw new Error("createPrismaTagStore: workspaceId must be a non-empty string");
+  const workspaceColumn = assertIdentifier(config.workspaceColumn, "workspaceColumn");
+  const tagModel = assertIdentifier(config.tagModel, "tagModel");
+  const tagTable = assertIdentifier(config.tagTable, "tagTable");
+  const tagRelation = assertIdentifier(config.tagRelation ?? "tag", "tagRelation");
+  const tagIdColumn = assertIdentifier(config.tagIdColumn ?? "tagId", "tagIdColumn");
+  const addedByColumn = assertIdentifier(config.addedByColumn ?? "addedBy", "addedByColumn");
+  const lockKeyPrefix = config.lockKeyPrefix ?? "tags:";
+  const lockWaitMs = config.lockWaitMs ?? 5e3;
+  if (!Number.isInteger(lockWaitMs) || lockWaitMs <= 0) throw new Error("createPrismaTagStore: lockWaitMs must be a positive integer");
+  const kinds = Object.keys(config.targets);
+  if (kinds.length === 0) throw new Error("createPrismaTagStore: targets must name at least one taggable kind");
+  const targets = new Map(kinds.map((kind) => [kind, resolveTarget(kind, config.targets[kind], workspaceColumn)]));
+  const lockKey = `${lockKeyPrefix}${config.workspaceId}`;
+  const txOptions = { maxWait: config.transaction?.maxWait ?? 1e4, timeout: config.transaction?.timeout ?? 15e3 };
+  const model = (client, name) => {
+    const found = client[name];
+    if (typeof found !== "object" || found === null) throw new Error(`createPrismaTagStore: the Prisma client has no model "${name}" (check the configuration)`);
+    return found;
+  };
+  return {
+    kinds,
+    workspaceId: config.workspaceId,
+    workspaceColumn,
+    tagRelation,
+    tagIdColumn,
+    addedByColumn,
+    sql: { tagTable: quote(tagTable), workspaceColumn: quote(workspaceColumn) },
+    target: (kind) => {
+      const found = targets.get(kind);
+      if (!found) throw new Error(`createPrismaTagStore: "${kind}" is not a configured taggable kind (configured: ${[...targets.keys()].join(", ")})`);
+      return found;
+    },
+    txOptions,
+    beforeLinkWrite: config.onBeforeLinkWrite,
+    client: config.client,
+    model,
+    tags: (client) => model(client, tagModel),
+    link: (client, kind) => model(client, targets.get(kind).linkModel),
+    tagWhere: (extra = {}) => ({ ...extra, [workspaceColumn]: config.workspaceId }),
+    async limitLockWait(tx) {
+      await tx.$executeRawUnsafe(`SELECT set_config('lock_timeout', $1, true)`, `${lockWaitMs}ms`);
+    },
+    async lockWorkspace(tx) {
+      await tx.$executeRawUnsafe(`SELECT pg_advisory_xact_lock(hashtext($1))`, lockKey);
+    }
+  };
+}
+
+// src/tags/prisma/errors.ts
+function hasCode(error, code, depth) {
+  if (typeof error !== "object" || error === null || depth > 4) return false;
+  const fields = error;
+  if (fields.code === code) return true;
+  return ["cause", "meta", "originalError", "driverAdapterError"].some((key) => hasCode(fields[key], code, depth + 1));
+}
+var isUniqueViolation = (error) => hasCode(error, "P2002", 0);
+var isForeignKeyViolation = (error) => hasCode(error, "P2003", 0);
+
+// src/tags/prisma/links.ts
+function createLinks(context, targetExists) {
+  return {
+    async applyLinks(kind, targetId, change, actorId) {
+      if (!await targetExists(kind, targetId)) return { kind: "targetGone" };
+      const target = context.target(kind);
+      const adding = [...new Set(change.add)];
+      const removing = [...new Set(change.remove)];
+      const asked = [.../* @__PURE__ */ new Set([...adding, ...removing])];
+      const known = /* @__PURE__ */ new Set();
+      if (asked.length > 0) {
+        const rows = await context.tags(context.client()).findMany({ where: context.tagWhere({ id: { in: asked } }), select: { id: true } });
+        for (const row of rows) known.add(row.id);
+      }
+      const attachable = adding.filter((id) => known.has(id));
+      const skipped = adding.filter((id) => !known.has(id));
+      const removable = removing.filter((id) => known.has(id));
+      if (context.beforeLinkWrite) await context.beforeLinkWrite();
+      if (attachable.length === 0 && removable.length === 0) return { kind: "applied", added: [], removed: [], skipped };
+      try {
+        const result = await context.client().$transaction(async (tx) => {
+          let added = [];
+          if (attachable.length > 0) {
+            const rows = await context.link(tx, kind).createManyAndReturn({
+              data: attachable.map((tagId) => ({ [target.targetColumn]: targetId, [context.tagIdColumn]: tagId, [context.addedByColumn]: actorId })),
+              skipDuplicates: true,
+              select: { [context.tagIdColumn]: true }
+            });
+            added = rows.map((row) => row[context.tagIdColumn]);
+          }
+          let removed = [];
+          if (removable.length > 0) {
+            const rows = await tx.$queryRawUnsafe(
+              `DELETE FROM ${quote(target.linkTable)} WHERE ${quote(target.targetColumn)} = $1 AND ${quote(context.tagIdColumn)} = ANY($2::text[]) RETURNING ${quote(context.tagIdColumn)} AS "tagId"`,
+              targetId,
+              removable
+            );
+            removed = rows.map((row) => row.tagId);
+          }
+          return { kind: "applied", added, removed, skipped };
+        }, context.txOptions);
+        if (result.added.length === 0 && result.removed.length === 0 && (attachable.length > 0 || removable.length > 0) && !await targetExists(kind, targetId)) return { kind: "targetGone" };
+        return result;
+      } catch (error) {
+        if (!isForeignKeyViolation(error)) throw error;
+        return await targetExists(kind, targetId) ? { kind: "tagGone" } : { kind: "targetGone" };
+      }
+    }
+  };
+}
+
+// src/tags/prisma/reads.ts
+function createReads(context) {
+  const { tagWhere } = context;
+  const db = () => context.client();
+  async function tagsOnTargets(kind, targetIds) {
+    if (targetIds.length === 0) return [];
+    const { targetColumn } = context.target(kind);
+    const rows = await context.link(db(), kind).findMany({
+      where: { [targetColumn]: { in: targetIds }, [context.tagRelation]: tagWhere() },
+      include: { [context.tagRelation]: true }
+    });
+    return rows.map((row) => ({ targetId: row[targetColumn], tag: row[context.tagRelation] }));
+  }
+  return {
+    async list() {
+      return await context.tags(db()).findMany({ where: tagWhere() });
+    },
+    async listPinned(limit) {
+      if (limit <= 0) return [];
+      return await context.tags(db()).findMany({ where: tagWhere({ pinned: true }), orderBy: [{ name: "asc" }, { id: "asc" }], take: limit });
+    },
+    async getMany(ids) {
+      if (ids.length === 0) return [];
+      return await context.tags(db()).findMany({ where: tagWhere({ id: { in: [...new Set(ids)] } }) });
+    },
+    async findByKey(nameKey) {
+      return await context.tags(db()).findFirst({ where: tagWhere({ nameKey }) });
+    },
+    async get(id) {
+      return await context.tags(db()).findFirst({ where: tagWhere({ id }) });
+    },
+    async targetExists(kind, targetId) {
+      const target = context.target(kind);
+      const row = await context.model(db(), target.targetModel).findFirst({ where: { id: targetId, [target.targetWorkspaceColumn]: context.workspaceId }, select: { id: true } });
+      return row !== null && row !== void 0;
+    },
+    async counts(ids) {
+      if (ids && ids.length === 0) return /* @__PURE__ */ new Map();
+      const tags = await context.tags(db()).findMany({ where: tagWhere(ids ? { id: { in: [...new Set(ids)] } } : {}), select: { id: true } });
+      const result = /* @__PURE__ */ new Map();
+      for (const { id } of tags) result.set(id, Object.fromEntries(context.kinds.map((kind) => [kind, 0])));
+      if (tags.length === 0) return result;
+      for (const kind of context.kinds) {
+        const grouped = await context.link(db(), kind).groupBy({ by: [context.tagIdColumn], where: { [context.tagIdColumn]: { in: tags.map((tag) => tag.id) } }, _count: { _all: true } });
+        for (const row of grouped) {
+          const entry = result.get(row[context.tagIdColumn]);
+          if (entry) entry[kind] = row._count._all;
+        }
+      }
+      return result;
+    },
+    async tagsForTarget(kind, targetId) {
+      return (await tagsOnTargets(kind, [targetId])).map((row) => row.tag);
+    },
+    async tagsForTargets(kind, targetIds) {
+      const result = /* @__PURE__ */ new Map();
+      for (const { targetId, tag } of await tagsOnTargets(kind, [...new Set(targetIds)])) {
+        const list = result.get(targetId) ?? [];
+        list.push(tag);
+        result.set(targetId, list);
+      }
+      return result;
+    }
+  };
+}
+
+// src/tags/prisma/writes.ts
+function createWrites(context) {
+  const { tagWhere } = context;
+  const db = () => context.client();
+  return {
+    async create(input, limits) {
+      try {
+        return await db().$transaction(async (tx) => {
+          await context.limitLockWait(tx);
+          await context.lockWorkspace(tx);
+          const tags = context.tags(tx);
+          if (await tags.count({ where: tagWhere() }) >= limits.maxTags) return { kind: "limit" };
+          if (await tags.findFirst({ where: tagWhere({ nameKey: input.nameKey }), select: { id: true } })) return { kind: "duplicate" };
+          const tag = await tags.create({ data: { ...tagWhere(), name: input.name, nameKey: input.nameKey, color: input.color } });
+          return { kind: "created", tag };
+        }, context.txOptions);
+      } catch (error) {
+        if (isUniqueViolation(error)) return { kind: "duplicate" };
+        throw error;
+      }
+    },
+    async update(id, patch, limits) {
+      const wantsPin = patch.pinned === true;
+      try {
+        return await db().$transaction(async (tx) => {
+          await context.limitLockWait(tx);
+          if (wantsPin) await context.lockWorkspace(tx);
+          const locked = await tx.$queryRawUnsafe(`SELECT "id" FROM ${context.sql.tagTable} WHERE "id" = $1 AND ${context.sql.workspaceColumn} = $2 FOR UPDATE`, id, context.workspaceId);
+          const tags = context.tags(tx);
+          const before = locked.length === 0 ? null : await tags.findFirst({ where: tagWhere({ id }) });
+          if (!before) return { kind: "notFound" };
+          if (patch.rename === void 0 && patch.color === void 0 && patch.pinned === void 0) return { kind: "updated", before, after: { ...before } };
+          if (wantsPin && !before.pinned && await tags.count({ where: tagWhere({ pinned: true }) }) >= limits.maxPinned) return { kind: "pinLimit" };
+          if (patch.rename && await tags.findFirst({ where: tagWhere({ nameKey: patch.rename.nameKey, NOT: { id } }), select: { id: true } })) return { kind: "duplicate" };
+          const data = {};
+          if (patch.rename) Object.assign(data, { name: patch.rename.name, nameKey: patch.rename.nameKey });
+          if (patch.color !== void 0) data.color = patch.color;
+          if (patch.pinned !== void 0) data.pinned = patch.pinned;
+          await tags.updateMany({ where: tagWhere({ id }), data });
+          const after = await tags.findFirst({ where: tagWhere({ id }) });
+          return { kind: "updated", before, after };
+        }, context.txOptions);
+      } catch (error) {
+        if (isUniqueViolation(error)) return { kind: "duplicate" };
+        throw error;
+      }
+    },
+    async remove(id) {
+      const tags = context.tags(db());
+      const tag = await tags.findFirst({ where: tagWhere({ id }) });
+      if (!tag) return { kind: "notFound" };
+      const { count } = await tags.deleteMany({ where: tagWhere({ id }) });
+      return count === 0 ? { kind: "notFound" } : { kind: "removed", tag };
+    }
+  };
+}
+
+// src/tags/prisma/index.ts
+function createPrismaTagStore(config) {
+  const context = createContext(config);
+  const reads = createReads(context);
+  return { ...reads, ...createWrites(context), ...createLinks(context, reads.targetExists) };
+}
+export {
+  createPrismaTagStore
+};