@apart-tech/intelligence-core 1.11.5 → 1.11.6

package/dist/services/tag-service.js

@@ -0,0 +1,639 @@
+import { Prisma } from "@prisma/client";
+import { SINGLE_TENANT_ORG_ID, tenantWhere } from "../db/tenant.js";
+// ── Errors ──────────────────────────────────────────────────────────────────
+export class TagValidationError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "TagValidationError";
+    }
+}
+export class TagNotFoundError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "TagNotFoundError";
+    }
+}
+// ── Service ─────────────────────────────────────────────────────────────────
+export class TagService {
+    db;
+    tenantCtx;
+    constructor(db, tenantCtx) {
+        this.db = db;
+        this.tenantCtx = tenantCtx ?? { organizationId: SINGLE_TENANT_ORG_ID };
+    }
+    // ── TagDefinition Management ────────────────────────────────────────────
+    async createDefinition(input) {
+        // Validate enum type requires enumValues
+        if (input.tagType === "enum" && (!input.enumValues || input.enumValues.length === 0)) {
+            throw new TagValidationError("Tag type 'enum' requires non-empty enumValues");
+        }
+        // Validate parent depth (max 3 levels)
+        if (input.parentDefinitionId) {
+            const depth = await this.getDefinitionDepth(input.parentDefinitionId);
+            if (depth >= 2) {
+                throw new TagValidationError("Tag definition hierarchy cannot exceed 3 levels");
+            }
+        }
+        // Validate dependsOn cycle detection
+        if (input.dependsOn && input.dependsOn.length > 0) {
+            // dependsOn references tagNames — validate they exist and no cycles
+            for (const depName of input.dependsOn) {
+                if (depName === input.tagName) {
+                    throw new TagValidationError(`Tag '${input.tagName}' cannot depend on itself`);
+                }
+                const dep = await this.getDefinitionByName(depName);
+                if (!dep) {
+                    throw new TagValidationError(`Dependency tag '${depName}' does not exist`);
+                }
+                // Check for circular: if the dep depends on input.tagName
+                const depDeps = dep.dependsOn || [];
+                if (depDeps.includes(input.tagName)) {
+                    throw new TagValidationError(`Circular dependency detected: '${depName}' already depends on '${input.tagName}'`);
+                }
+            }
+        }
+        return this.db.tagDefinition.create({
+            data: {
+                tagName: input.tagName,
+                tagType: input.tagType,
+                cardinality: input.cardinality ?? "singleton",
+                source: input.source ?? "extracted",
+                description: input.description ?? "",
+                category: input.category ?? null,
+                labels: input.labels ?? Prisma.JsonNull,
+                applicableNodeTypes: input.applicableNodeTypes ?? [],
+                requiredForNodeTypes: input.requiredForNodeTypes ?? [],
+                enumValues: input.enumValues ?? Prisma.JsonNull,
+                dependsOn: input.dependsOn ?? [],
+                autoAcceptThreshold: input.autoAcceptThreshold ?? null,
+                parentDefinitionId: input.parentDefinitionId ?? null,
+                createdBy: input.createdBy,
+                organizationId: this.tenantCtx.organizationId,
+            },
+        });
+    }
+    async updateDefinition(id, input) {
+        const existing = await this.db.tagDefinition.findUnique({ where: { id } });
+        if (!existing) {
+            throw new TagNotFoundError(`TagDefinition ${id} not found`);
+        }
+        const data = {};
+        if (input.description !== undefined)
+            data.description = input.description;
+        if (input.category !== undefined)
+            data.category = input.category;
+        if (input.labels !== undefined)
+            data.labels = input.labels;
+        if (input.applicableNodeTypes !== undefined)
+            data.applicableNodeTypes = input.applicableNodeTypes;
+        if (input.requiredForNodeTypes !== undefined)
+            data.requiredForNodeTypes = input.requiredForNodeTypes;
+        if (input.autoAcceptThreshold !== undefined)
+            data.autoAcceptThreshold = input.autoAcceptThreshold;
+        if (input.replacedBy !== undefined)
+            data.replacedBy = input.replacedBy;
+        if (input.enumValues !== undefined) {
+            data.enumValues = input.enumValues;
+            data.enumVersion = (existing.enumVersion ?? 1) + 1;
+        }
+        if (input.status !== undefined) {
+            data.status = input.status;
+            if (input.status === "deprecated" && !existing.deprecatedAt) {
+                data.deprecatedAt = new Date();
+            }
+        }
+        return this.db.tagDefinition.update({ where: { id }, data });
+    }
+    async getDefinition(id) {
+        return this.db.tagDefinition.findUnique({ where: { id } });
+    }
+    async getDefinitionByName(tagName) {
+        // Org-scoped first
+        const orgDef = await this.db.tagDefinition.findFirst({
+            where: { tagName, organizationId: this.tenantCtx.organizationId },
+        });
+        if (orgDef)
+            return orgDef;
+        // Fall back to system templates (organizationId = NULL)
+        return this.db.tagDefinition.findFirst({
+            where: { tagName, organizationId: null },
+        });
+    }
+    async listDefinitions(options) {
+        const where = {};
+        if (options?.status)
+            where.status = options.status;
+        if (options?.category)
+            where.category = options.category;
+        // Include both org-specific and system templates
+        const [orgDefs, systemDefs] = await Promise.all([
+            this.db.tagDefinition.findMany({
+                where: { ...where, organizationId: this.tenantCtx.organizationId },
+                orderBy: { tagName: "asc" },
+            }),
+            this.db.tagDefinition.findMany({
+                where: { ...where, organizationId: null },
+                orderBy: { tagName: "asc" },
+            }),
+        ]);
+        // System templates that aren't overridden by org-specific defs
+        const orgNames = new Set(orgDefs.map((d) => d.tagName));
+        const uniqueSystemDefs = systemDefs.filter((d) => !orgNames.has(d.tagName));
+        return [...orgDefs, ...uniqueSystemDefs].sort((a, b) => a.tagName.localeCompare(b.tagName));
+    }
+    // ── Core Tag Operations ─────────────────────────────────────────────────
+    async applyTags(nodeId, tags, taggedBy) {
+        const results = [];
+        for (const tag of tags) {
+            const result = await this.applySingleTag(nodeId, tag, taggedBy);
+            results.push(result);
+        }
+        return results;
+    }
+    async applySingleTag(nodeId, input, taggedBy) {
+        // 1. Look up definition
+        const def = await this.getDefinitionByName(input.tagName);
+        if (!def) {
+            throw new TagValidationError(`Unknown tag name '${input.tagName}'`);
+        }
+        // 2. Status check
+        if (def.status === "retired") {
+            throw new TagValidationError(`Tag '${input.tagName}' is retired and cannot be used`);
+        }
+        if (def.status === "deprecated") {
+            // Grace period: 1 hour after deprecatedAt
+            const graceEnd = def.deprecatedAt
+                ? new Date(def.deprecatedAt.getTime() + 60 * 60 * 1000)
+                : null;
+            if (graceEnd && new Date() > graceEnd) {
+                throw new TagValidationError(`Tag '${input.tagName}' is deprecated (grace period expired)`);
+            }
+        }
+        // 3. Type validation
+        this.validateTagType(def.tagType, input);
+        // 4. Enum check
+        if (def.tagType === "enum" && input.valueText) {
+            const allowed = def.enumValues || [];
+            if (!allowed.includes(input.valueText)) {
+                throw new TagValidationError(`Value '${input.valueText}' is not in enum values for '${input.tagName}': [${allowed.join(", ")}]`);
+            }
+        }
+        // 5. Currency enforcement for number tags
+        if (def.tagType === "number" && input.valueCurrency) {
+            if (input.valueCurrency.length !== 3) {
+                throw new TagValidationError("valueCurrency must be a 3-letter ISO currency code");
+            }
+        }
+        // 6. Determine verification status
+        let verificationStatus = "unverified";
+        if (def.autoAcceptThreshold !== null &&
+            input.confidence !== undefined &&
+            input.confidence >= def.autoAcceptThreshold) {
+            verificationStatus = "auto-accepted";
+        }
+        const isSingleton = def.cardinality === "singleton";
+        const orgId = this.tenantCtx.organizationId;
+        // 7. Singleton: raw SQL UPSERT with IS DISTINCT FROM guard
+        if (isSingleton) {
+            const result = await this.upsertSingletonRaw(nodeId, orgId, def, input, taggedBy, verificationStatus);
+            return result;
+        }
+        // 8. Multi: plain INSERT via Prisma
+        const created = await this.db.nodeTag.create({
+            data: {
+                nodeId,
+                organizationId: orgId,
+                tagDefinitionId: def.id,
+                tagName: input.tagName,
+                isSingleton: false,
+                valueText: input.valueText ?? null,
+                valueNum: input.valueNum ?? null,
+                valueCurrency: input.valueCurrency ?? null,
+                valueUnit: input.valueUnit ?? null,
+                valueDate: input.valueDate ? new Date(input.valueDate) : null,
+                valueRef: input.valueRef ?? null,
+                textSpan: input.textSpan ?? null,
+                offsetStart: input.offsetStart ?? null,
+                offsetEnd: input.offsetEnd ?? null,
+                contentVersion: input.contentVersion ?? null,
+                attrs: (input.attrs ?? {}),
+                taggedBy,
+                modelId: input.modelId ?? null,
+                modelVersion: input.modelVersion ?? null,
+                confidence: input.confidence ?? null,
+                verificationStatus,
+            },
+        });
+        // Write audit
+        await this.writeAudit(created.id, nodeId, orgId, "apply", null, this.tagValueSnapshot(created), taggedBy);
+        return created;
+    }
+    async upsertSingletonRaw(nodeId, orgId, def, input, taggedBy, verificationStatus) {
+        // The UPSERT with IS DISTINCT FROM guard — only updates if the value actually changed.
+        // The BEFORE UPDATE trigger on node_tags copies the old value to history.
+        const rows = await this.db.$queryRaw `
+      INSERT INTO node_tags (
+        id, node_id, organization_id, tag_definition_id, tag_name, is_singleton,
+        value_text, value_num, value_currency, value_unit, value_date, value_ref,
+        text_span, offset_start, offset_end, content_version, attrs,
+        tagged_by, model_id, model_version, confidence, verification_status,
+        created_at, updated_at
+      ) VALUES (
+        gen_random_uuid(), ${nodeId}::uuid, ${orgId}::uuid, ${def.id}::uuid,
+        ${input.tagName}, true,
+        ${input.valueText ?? null}, ${input.valueNum ?? null},
+        ${input.valueCurrency ?? null}, ${input.valueUnit ?? null},
+        ${input.valueDate ? new Date(input.valueDate) : null}::timestamptz,
+        ${input.valueRef ?? null}::uuid,
+        ${input.textSpan ?? null}, ${input.offsetStart ?? null},
+        ${input.offsetEnd ?? null}, ${input.contentVersion ?? null},
+        ${JSON.stringify(input.attrs ?? {})}::jsonb,
+        ${taggedBy}, ${input.modelId ?? null}, ${input.modelVersion ?? null},
+        ${input.confidence ?? null}, ${verificationStatus},
+        NOW(), NOW()
+      )
+      ON CONFLICT (node_id, tag_name) WHERE is_singleton = true
+      DO UPDATE SET
+        value_text = EXCLUDED.value_text,
+        value_num = EXCLUDED.value_num,
+        value_currency = EXCLUDED.value_currency,
+        value_unit = EXCLUDED.value_unit,
+        value_date = EXCLUDED.value_date,
+        value_ref = EXCLUDED.value_ref,
+        text_span = EXCLUDED.text_span,
+        offset_start = EXCLUDED.offset_start,
+        offset_end = EXCLUDED.offset_end,
+        content_version = EXCLUDED.content_version,
+        attrs = EXCLUDED.attrs,
+        tagged_by = EXCLUDED.tagged_by,
+        model_id = EXCLUDED.model_id,
+        model_version = EXCLUDED.model_version,
+        confidence = EXCLUDED.confidence,
+        verification_status = EXCLUDED.verification_status,
+        updated_at = NOW()
+      WHERE node_tags.value_text IS DISTINCT FROM EXCLUDED.value_text
+         OR node_tags.value_num IS DISTINCT FROM EXCLUDED.value_num
+         OR node_tags.value_date IS DISTINCT FROM EXCLUDED.value_date
+         OR node_tags.value_ref IS DISTINCT FROM EXCLUDED.value_ref
+      RETURNING *
+    `;
+        if (rows.length === 0) {
+            // No-op update (values identical) — return the existing row
+            const existing = await this.db.nodeTag.findFirst({
+                where: { nodeId, tagName: input.tagName, isSingleton: true },
+            });
+            if (!existing) {
+                throw new TagNotFoundError(`Singleton tag '${input.tagName}' on node ${nodeId} not found after UPSERT`);
+            }
+            return existing;
+        }
+        const result = rows[0];
+        await this.writeAudit(result.id, nodeId, orgId, "apply", null, this.tagValueSnapshot(result), taggedBy);
+        return result;
+    }
+    async upsertSingleton(nodeId, input, taggedBy) {
+        const results = await this.applyTags(nodeId, [input], taggedBy);
+        return results[0];
+    }
+    async getNodeTags(nodeId, tagNames) {
+        const where = {
+            nodeId,
+            supersededBy: null,
+        };
+        if (tagNames && tagNames.length > 0) {
+            where.tagName = { in: tagNames };
+        }
+        return this.db.nodeTag.findMany({ where, orderBy: { tagName: "asc" } });
+    }
+    async queryTags(query) {
+        const orgWhere = tenantWhere(this.tenantCtx, "t");
+        const filterConditions = this.buildFilterConditions(query.filters, "t");
+        const activeCondition = Prisma.sql `t.superseded_by IS NULL`;
+        const whereClause = Prisma.sql `${orgWhere} AND ${activeCondition} AND ${filterConditions}`;
+        // Simple query: return matching node IDs with tag values
+        if (!query.aggregations || query.aggregations.length === 0) {
+            const limitVal = query.limit ?? 100;
+            const offsetVal = query.offset ?? 0;
+            const countResult = await this.db.$queryRaw `
+        SELECT COUNT(DISTINCT t.node_id) as count
+        FROM node_tags t
+        WHERE ${whereClause}
+      `;
+            const rows = await this.db.$queryRaw `
+        SELECT DISTINCT t.node_id, t.tag_name, t.value_text, t.value_num,
+               t.value_currency, t.value_unit, t.value_date, t.value_ref,
+               t.confidence, t.verification_status
+        FROM node_tags t
+        WHERE ${whereClause}
+        ORDER BY t.tag_name, t.node_id
+        LIMIT ${limitVal} OFFSET ${offsetVal}
+      `;
+            return {
+                rows: rows,
+                total: Number(countResult[0].count),
+            };
+        }
+        // Aggregation query
+        const aggSelects = query.aggregations.map((agg) => {
+            const col = this.getValueColumn(agg.tagName);
+            switch (agg.fn) {
+                case "count":
+                    return Prisma.sql `COUNT(*) as "${Prisma.raw(`${agg.fn}_${agg.tagName}`)}"`;
+                case "sum":
+                    return Prisma.sql `SUM(t.value_num) as "${Prisma.raw(`${agg.fn}_${agg.tagName}`)}"`;
+                case "avg":
+                    return Prisma.sql `AVG(t.value_num) as "${Prisma.raw(`${agg.fn}_${agg.tagName}`)}"`;
+                case "min":
+                    return Prisma.sql `MIN(${col}) as "${Prisma.raw(`${agg.fn}_${agg.tagName}`)}"`;
+                case "max":
+                    return Prisma.sql `MAX(${col}) as "${Prisma.raw(`${agg.fn}_${agg.tagName}`)}"`;
+            }
+        });
+        const selectClause = Prisma.join(aggSelects, ", ");
+        let groupByClause = Prisma.sql ``;
+        let extraSelect = Prisma.sql ``;
+        if (query.groupBy && query.groupBy.length > 0) {
+            // Mandatory: group by currency when aggregating numerics
+            const groupCols = query.groupBy.map((g) => Prisma.raw(`t.${g}`));
+            groupByClause = Prisma.sql `GROUP BY ${Prisma.join(groupCols, ", ")}`;
+            const groupSelects = query.groupBy.map((g) => Prisma.sql `${Prisma.raw(`t.${g}`)}`);
+            extraSelect = Prisma.sql `${Prisma.join(groupSelects, ", ")}, `;
+        }
+        const rows = await this.db.$queryRaw `
+      SELECT ${extraSelect}${selectClause}
+      FROM node_tags t
+      WHERE ${whereClause}
+      ${groupByClause}
+    `;
+        return { rows: rows, total: rows.length };
+    }
+    // ── Verification ────────────────────────────────────────────────────────
+    async verifyTag(tagId, verifiedBy, reason) {
+        const tag = await this.db.nodeTag.findUnique({ where: { id: tagId } });
+        if (!tag)
+            throw new TagNotFoundError(`Tag ${tagId} not found`);
+        const updated = await this.db.nodeTag.update({
+            where: { id: tagId },
+            data: {
+                verificationStatus: "human-verified",
+                verifiedBy,
+                verifiedAt: new Date(),
+                updatedAt: new Date(),
+            },
+        });
+        await this.writeAudit(tagId, tag.nodeId, tag.organizationId, "verify", { verificationStatus: tag.verificationStatus }, { verificationStatus: "human-verified" }, verifiedBy, reason);
+        return updated;
+    }
+    async contestTag(tagId, contestedBy, reason) {
+        const tag = await this.db.nodeTag.findUnique({ where: { id: tagId } });
+        if (!tag)
+            throw new TagNotFoundError(`Tag ${tagId} not found`);
+        const updated = await this.db.nodeTag.update({
+            where: { id: tagId },
+            data: {
+                verificationStatus: "contested",
+                updatedAt: new Date(),
+            },
+        });
+        await this.writeAudit(tagId, tag.nodeId, tag.organizationId, "contest", { verificationStatus: tag.verificationStatus }, { verificationStatus: "contested" }, contestedBy, reason);
+        return updated;
+    }
+    // ── Bulk Operations ─────────────────────────────────────────────────────
+    async bulkApply(tags, taggedBy) {
+        const batchId = crypto.randomUUID();
+        const applied = [];
+        const errors = [];
+        // Process in 500-row sub-batches (Phase 1: optimistic concurrency)
+        const batchSize = 500;
+        for (let i = 0; i < tags.length; i += batchSize) {
+            const batch = tags.slice(i, i + batchSize);
+            for (let j = 0; j < batch.length; j++) {
+                const { nodeId, ...tagInput } = batch[j];
+                try {
+                    const result = await this.applySingleTag(nodeId, tagInput, taggedBy);
+                    // Set batchId on the result
+                    await this.db.nodeTag.update({
+                        where: { id: result.id },
+                        data: { batchId },
+                    });
+                    applied.push({ ...result, batchId });
+                }
+                catch (err) {
+                    errors.push({
+                        index: i + j,
+                        tagName: tagInput.tagName,
+                        error: err instanceof Error ? err.message : String(err),
+                    });
+                }
+            }
+        }
+        return { applied, errors };
+    }
+    async rollbackBatch(batchId) {
+        // Delete all tags in the batch — triggers will create history rows
+        const result = await this.db.nodeTag.deleteMany({
+            where: { batchId },
+        });
+        return result.count;
+    }
+    // ── History ─────────────────────────────────────────────────────────────
+    async getTagAtTime(nodeId, tagName, asOf) {
+        const orgWhere = tenantWhere(this.tenantCtx);
+        const rows = await this.db.$queryRaw `
+      SELECT value_text, value_num, value_currency, value_unit, value_date, value_ref,
+             valid_from, valid_until
+      FROM node_tag_history
+      WHERE node_id = ${nodeId}::uuid AND tag_name = ${tagName}
+        AND ${orgWhere}
+        AND valid_from <= ${asOf}::timestamptz AND valid_until > ${asOf}::timestamptz
+      UNION ALL
+      SELECT value_text, value_num, value_currency, value_unit, value_date, value_ref,
+             created_at AS valid_from, NULL::timestamptz AS valid_until
+      FROM node_tags
+      WHERE node_id = ${nodeId}::uuid AND tag_name = ${tagName}
+        AND ${orgWhere}
+        AND created_at <= ${asOf}::timestamptz
+        AND superseded_by IS NULL
+      ORDER BY valid_from DESC LIMIT 1
+    `;
+        return rows.length > 0 ? rows[0] : null;
+    }
+    // ── Private Helpers ─────────────────────────────────────────────────────
+    validateTagType(tagType, input) {
+        switch (tagType) {
+            case "text":
+            case "enum":
+                if (input.valueText === undefined && input.valueNum === undefined) {
+                    // Allow either — text-typed tags primarily use valueText
+                }
+                break;
+            case "number":
+                if (input.valueNum === undefined) {
+                    throw new TagValidationError(`Tag type 'number' requires valueNum`);
+                }
+                break;
+            case "date":
+                if (input.valueDate === undefined) {
+                    throw new TagValidationError(`Tag type 'date' requires valueDate`);
+                }
+                break;
+            case "ref":
+                if (input.valueRef === undefined) {
+                    throw new TagValidationError(`Tag type 'ref' requires valueRef`);
+                }
+                break;
+        }
+    }
+    async getDefinitionDepth(definitionId) {
+        let depth = 0;
+        let currentId = definitionId;
+        while (currentId) {
+            const found = await this.db.tagDefinition.findUnique({
+                where: { id: currentId },
+                select: { parentDefinitionId: true },
+            });
+            if (!found?.parentDefinitionId)
+                break;
+            depth++;
+            currentId = found.parentDefinitionId;
+            if (depth > 10)
+                break; // Safety valve
+        }
+        return depth;
+    }
+    buildFilterConditions(filters, alias) {
+        if (filters.length === 0)
+            return Prisma.sql `TRUE`;
+        const conditions = filters.map((f) => {
+            const tagNameCond = Prisma.sql `${Prisma.raw(alias)}.tag_name = ${f.tagName}`;
+            if (f.op === "exists") {
+                return tagNameCond;
+            }
+            const col = this.resolveFilterColumn(f, alias);
+            switch (f.op) {
+                case "eq":
+                    return Prisma.sql `${tagNameCond} AND ${col} = ${f.value}`;
+                case "neq":
+                    return Prisma.sql `${tagNameCond} AND ${col} != ${f.value}`;
+                case "gt":
+                    return Prisma.sql `${tagNameCond} AND ${col} > ${f.value}`;
+                case "gte":
+                    return Prisma.sql `${tagNameCond} AND ${col} >= ${f.value}`;
+                case "lt":
+                    return Prisma.sql `${tagNameCond} AND ${col} < ${f.value}`;
+                case "lte":
+                    return Prisma.sql `${tagNameCond} AND ${col} <= ${f.value}`;
+                case "between":
+                    return Prisma.sql `${tagNameCond} AND ${col} BETWEEN ${f.value} AND ${f.valueTo}`;
+                case "in":
+                    if (Array.isArray(f.value)) {
+                        return Prisma.sql `${tagNameCond} AND ${col} = ANY(${f.value}::text[])`;
+                    }
+                    return tagNameCond;
+                case "contains":
+                    return Prisma.sql `${tagNameCond} AND ${col} ILIKE ${"%" + String(f.value) + "%"}`;
+                default:
+                    return tagNameCond;
+            }
+        });
+        return Prisma.join(conditions, " AND ");
+    }
+    resolveFilterColumn(filter, alias) {
+        const val = filter.value;
+        if (typeof val === "number")
+            return Prisma.raw(`${alias}.value_num`);
+        if (val instanceof Date)
+            return Prisma.raw(`${alias}.value_date`);
+        return Prisma.raw(`${alias}.value_text`);
+    }
+    getValueColumn(_tagName) {
+        // In a richer implementation, this would look up the definition's tagType.
+        // For now, default to value_num for aggregations.
+        return Prisma.raw("t.value_num");
+    }
+    /**
+     * Build tag filter conditions as EXISTS subqueries for search integration.
+     * Each TagFilter becomes:
+     *   EXISTS (SELECT 1 FROM node_tags t WHERE t.node_id = nodes.id
+     *     AND t.tag_name = :tagName AND t.superseded_by IS NULL AND <op condition>)
+     */
+    buildSearchTagCondition(filters) {
+        if (filters.length === 0)
+            return Prisma.sql `TRUE`;
+        const existsConditions = filters.map((f) => {
+            const baseCond = Prisma.sql `t.node_id = nodes.id AND t.tag_name = ${f.tagName} AND t.superseded_by IS NULL`;
+            if (f.op === "exists") {
+                return Prisma.sql `EXISTS (SELECT 1 FROM node_tags t WHERE ${baseCond})`;
+            }
+            let opCond;
+            switch (f.op) {
+                case "eq":
+                    if (typeof f.value === "number") {
+                        opCond = Prisma.sql `t.value_num = ${f.value}`;
+                    }
+                    else {
+                        opCond = Prisma.sql `t.value_text = ${String(f.value)}`;
+                    }
+                    break;
+                case "neq":
+                    if (typeof f.value === "number") {
+                        opCond = Prisma.sql `t.value_num != ${f.value}`;
+                    }
+                    else {
+                        opCond = Prisma.sql `t.value_text != ${String(f.value)}`;
+                    }
+                    break;
+                case "gt":
+                    opCond = Prisma.sql `t.value_num > ${f.value}`;
+                    break;
+                case "gte":
+                    opCond = Prisma.sql `t.value_num >= ${f.value}`;
+                    break;
+                case "lt":
+                    opCond = Prisma.sql `t.value_num < ${f.value}`;
+                    break;
+                case "lte":
+                    opCond = Prisma.sql `t.value_num <= ${f.value}`;
+                    break;
+                case "between":
+                    opCond = Prisma.sql `t.value_num BETWEEN ${f.value} AND ${f.valueTo}`;
+                    break;
+                case "in":
+                    if (Array.isArray(f.value)) {
+                        opCond = Prisma.sql `t.value_text = ANY(${f.value}::text[])`;
+                    }
+                    else {
+                        opCond = Prisma.sql `TRUE`;
+                    }
+                    break;
+                case "contains":
+                    opCond = Prisma.sql `t.value_text ILIKE ${"%" + String(f.value) + "%"}`;
+                    break;
+                default:
+                    opCond = Prisma.sql `TRUE`;
+            }
+            return Prisma.sql `EXISTS (SELECT 1 FROM node_tags t WHERE ${baseCond} AND ${opCond})`;
+        });
+        return Prisma.join(existsConditions, " AND ");
+    }
+    tagValueSnapshot(tag) {
+        return {
+            valueText: tag.valueText,
+            valueNum: tag.valueNum,
+            valueCurrency: tag.valueCurrency,
+            valueUnit: tag.valueUnit,
+            valueDate: tag.valueDate,
+            valueRef: tag.valueRef,
+        };
+    }
+    async writeAudit(tagId, nodeId, orgId, action, oldValue, newValue, actorId, reason) {
+        await this.db.$queryRaw `
+      INSERT INTO node_tag_audit (id, tag_id, node_id, organization_id, action, old_value, new_value, actor_id, reason)
+      VALUES (gen_random_uuid(), ${tagId}::uuid, ${nodeId}::uuid, ${orgId}::uuid,
+              ${action}, ${oldValue ? JSON.stringify(oldValue) : null}::jsonb,
+              ${newValue ? JSON.stringify(newValue) : null}::jsonb,
+              ${actorId}::uuid, ${reason ?? null})
+    `;
+    }
+}
+//# sourceMappingURL=tag-service.js.map