weave-typescript 0.26.0 → 0.28.0

package/dist/weavesql/weavedb/consolidation_sql.js

@@ -0,0 +1,470 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.clearThreadClusterAssignmentsByOrganizationQuery = exports.assignThreadsToClusterQuery = exports.listApprovedThreadsForConsolidationQuery = exports.listConceptClustersByParentAndRealmQuery = exports.listConceptClustersByRealmQuery = exports.getConceptClusterByOrganizationRealmAndIDQuery = exports.upsertConceptClusterQuery = exports.listConsolidationRunsByOrganizationQuery = exports.updateConsolidationRunStateQuery = exports.getConsolidationRunByOrganizationAndIDQuery = exports.createConsolidationRunQuery = void 0;
+exports.createConsolidationRun = createConsolidationRun;
+exports.getConsolidationRunByOrganizationAndID = getConsolidationRunByOrganizationAndID;
+exports.updateConsolidationRunState = updateConsolidationRunState;
+exports.listConsolidationRunsByOrganization = listConsolidationRunsByOrganization;
+exports.upsertConceptCluster = upsertConceptCluster;
+exports.getConceptClusterByOrganizationRealmAndID = getConceptClusterByOrganizationRealmAndID;
+exports.listConceptClustersByRealm = listConceptClustersByRealm;
+exports.listConceptClustersByParentAndRealm = listConceptClustersByParentAndRealm;
+exports.listApprovedThreadsForConsolidation = listApprovedThreadsForConsolidation;
+exports.createConsolidationRunQuery = `-- name: CreateConsolidationRun :one
+INSERT INTO weave.consolidation_runs (
+    id,
+    organization_id,
+    status
+) VALUES (
+    $1,
+    $2,
+    $3
+)
+RETURNING
+    id,
+    organization_id,
+    status,
+    thread_count,
+    cluster_count,
+    hierarchy_depth,
+    error,
+    started_at,
+    completed_at`;
+async function createConsolidationRun(client, args) {
+    const result = await client.query({
+        text: exports.createConsolidationRunQuery,
+        values: [args.id, args.organizationId, args.status],
+        rowMode: "array"
+    });
+    if (result.rows.length !== 1) {
+        return null;
+    }
+    const row = result.rows[0];
+    return {
+        id: row[0],
+        organizationId: row[1],
+        status: row[2],
+        threadCount: row[3],
+        clusterCount: row[4],
+        hierarchyDepth: row[5],
+        error: row[6],
+        startedAt: row[7],
+        completedAt: row[8]
+    };
+}
+exports.getConsolidationRunByOrganizationAndIDQuery = `-- name: GetConsolidationRunByOrganizationAndID :one
+SELECT
+    id,
+    organization_id,
+    status,
+    thread_count,
+    cluster_count,
+    hierarchy_depth,
+    error,
+    started_at,
+    completed_at
+FROM weave.consolidation_runs
+WHERE organization_id = $1
+  AND id = $2`;
+async function getConsolidationRunByOrganizationAndID(client, args) {
+    const result = await client.query({
+        text: exports.getConsolidationRunByOrganizationAndIDQuery,
+        values: [args.organizationId, args.id],
+        rowMode: "array"
+    });
+    if (result.rows.length !== 1) {
+        return null;
+    }
+    const row = result.rows[0];
+    return {
+        id: row[0],
+        organizationId: row[1],
+        status: row[2],
+        threadCount: row[3],
+        clusterCount: row[4],
+        hierarchyDepth: row[5],
+        error: row[6],
+        startedAt: row[7],
+        completedAt: row[8]
+    };
+}
+exports.updateConsolidationRunStateQuery = `-- name: UpdateConsolidationRunState :one
+UPDATE weave.consolidation_runs
+SET
+    status = $1,
+    thread_count = $2,
+    cluster_count = $3,
+    hierarchy_depth = $4,
+    error = $5,
+    completed_at = $6
+WHERE id = $7
+  AND organization_id = $8
+RETURNING
+    id,
+    organization_id,
+    status,
+    thread_count,
+    cluster_count,
+    hierarchy_depth,
+    error,
+    started_at,
+    completed_at`;
+async function updateConsolidationRunState(client, args) {
+    const result = await client.query({
+        text: exports.updateConsolidationRunStateQuery,
+        values: [args.status, args.threadCount, args.clusterCount, args.hierarchyDepth, args.error, args.completedAt, args.id, args.organizationId],
+        rowMode: "array"
+    });
+    if (result.rows.length !== 1) {
+        return null;
+    }
+    const row = result.rows[0];
+    return {
+        id: row[0],
+        organizationId: row[1],
+        status: row[2],
+        threadCount: row[3],
+        clusterCount: row[4],
+        hierarchyDepth: row[5],
+        error: row[6],
+        startedAt: row[7],
+        completedAt: row[8]
+    };
+}
+exports.listConsolidationRunsByOrganizationQuery = `-- name: ListConsolidationRunsByOrganization :many
+SELECT
+    id,
+    organization_id,
+    status,
+    thread_count,
+    cluster_count,
+    hierarchy_depth,
+    error,
+    started_at,
+    completed_at
+FROM weave.consolidation_runs
+WHERE organization_id = $1
+ORDER BY started_at DESC
+LIMIT $3 OFFSET $2`;
+async function listConsolidationRunsByOrganization(client, args) {
+    const result = await client.query({
+        text: exports.listConsolidationRunsByOrganizationQuery,
+        values: [args.organizationId, args.pageOffset, args.pageSize],
+        rowMode: "array"
+    });
+    return result.rows.map(row => {
+        return {
+            id: row[0],
+            organizationId: row[1],
+            status: row[2],
+            threadCount: row[3],
+            clusterCount: row[4],
+            hierarchyDepth: row[5],
+            error: row[6],
+            startedAt: row[7],
+            completedAt: row[8]
+        };
+    });
+}
+exports.upsertConceptClusterQuery = `-- name: UpsertConceptCluster :one
+INSERT INTO weave.concept_clusters (
+    id,
+    organization_id,
+    realm_kind,
+    realm_key,
+    name,
+    description,
+    knowledge_type,
+    level,
+    parent_id,
+    embedding,
+    centroid,
+    thread_count,
+    consolidation_run_id
+) VALUES (
+    $1,
+    $2,
+    $3,
+    $4,
+    $5,
+    $6,
+    $7,
+    $8,
+    $9,
+    $10::vector,
+    $11::vector,
+    $12,
+    $13
+)
+ON CONFLICT (id) DO UPDATE
+SET
+    name = EXCLUDED.name,
+    description = EXCLUDED.description,
+    realm_kind = EXCLUDED.realm_kind,
+    realm_key = EXCLUDED.realm_key,
+    knowledge_type = EXCLUDED.knowledge_type,
+    level = EXCLUDED.level,
+    parent_id = EXCLUDED.parent_id,
+    embedding = EXCLUDED.embedding,
+    centroid = EXCLUDED.centroid,
+    thread_count = EXCLUDED.thread_count,
+    consolidation_run_id = EXCLUDED.consolidation_run_id,
+    updated_at = now()
+RETURNING
+    id,
+    organization_id,
+    realm_kind,
+    realm_key,
+    name,
+    description,
+    knowledge_type,
+    level,
+    parent_id,
+    thread_count,
+    consolidation_run_id,
+    created_at,
+    updated_at`;
+async function upsertConceptCluster(client, args) {
+    const result = await client.query({
+        text: exports.upsertConceptClusterQuery,
+        values: [args.id, args.organizationId, args.realmKind, args.realmKey, args.name, args.description, args.knowledgeType, args.level, args.parentId, args.embedding, args.centroid, args.threadCount, args.consolidationRunId],
+        rowMode: "array"
+    });
+    if (result.rows.length !== 1) {
+        return null;
+    }
+    const row = result.rows[0];
+    return {
+        id: row[0],
+        organizationId: row[1],
+        realmKind: row[2],
+        realmKey: row[3],
+        name: row[4],
+        description: row[5],
+        knowledgeType: row[6],
+        level: row[7],
+        parentId: row[8],
+        threadCount: row[9],
+        consolidationRunId: row[10],
+        createdAt: row[11],
+        updatedAt: row[12]
+    };
+}
+exports.getConceptClusterByOrganizationRealmAndIDQuery = `-- name: GetConceptClusterByOrganizationRealmAndID :one
+SELECT
+    id,
+    organization_id,
+    realm_kind,
+    realm_key,
+    name,
+    description,
+    knowledge_type,
+    level,
+    parent_id,
+    thread_count,
+    consolidation_run_id,
+    created_at,
+    updated_at
+FROM weave.concept_clusters
+WHERE organization_id = $1
+  AND realm_kind = $2
+  AND realm_key = $3
+  AND id = $4`;
+async function getConceptClusterByOrganizationRealmAndID(client, args) {
+    const result = await client.query({
+        text: exports.getConceptClusterByOrganizationRealmAndIDQuery,
+        values: [args.organizationId, args.realmKind, args.realmKey, args.id],
+        rowMode: "array"
+    });
+    if (result.rows.length !== 1) {
+        return null;
+    }
+    const row = result.rows[0];
+    return {
+        id: row[0],
+        organizationId: row[1],
+        realmKind: row[2],
+        realmKey: row[3],
+        name: row[4],
+        description: row[5],
+        knowledgeType: row[6],
+        level: row[7],
+        parentId: row[8],
+        threadCount: row[9],
+        consolidationRunId: row[10],
+        createdAt: row[11],
+        updatedAt: row[12]
+    };
+}
+exports.listConceptClustersByRealmQuery = `-- name: ListConceptClustersByRealm :many
+SELECT
+    id,
+    organization_id,
+    realm_kind,
+    realm_key,
+    name,
+    description,
+    knowledge_type,
+    level,
+    parent_id,
+    thread_count,
+    consolidation_run_id,
+    created_at,
+    updated_at
+FROM weave.concept_clusters
+WHERE organization_id = $1
+  AND realm_kind = $2
+  AND realm_key = $3
+  AND ($4 = '' OR knowledge_type = $4)
+  AND ($5 <= 0 OR level <= $5)
+ORDER BY level ASC, updated_at DESC, id ASC`;
+async function listConceptClustersByRealm(client, args) {
+    const result = await client.query({
+        text: exports.listConceptClustersByRealmQuery,
+        values: [args.organizationId, args.realmKind, args.realmKey, args.knowledgeType, args.maxDepth],
+        rowMode: "array"
+    });
+    return result.rows.map(row => {
+        return {
+            id: row[0],
+            organizationId: row[1],
+            realmKind: row[2],
+            realmKey: row[3],
+            name: row[4],
+            description: row[5],
+            knowledgeType: row[6],
+            level: row[7],
+            parentId: row[8],
+            threadCount: row[9],
+            consolidationRunId: row[10],
+            createdAt: row[11],
+            updatedAt: row[12]
+        };
+    });
+}
+exports.listConceptClustersByParentAndRealmQuery = `-- name: ListConceptClustersByParentAndRealm :many
+SELECT
+    id,
+    organization_id,
+    realm_kind,
+    realm_key,
+    name,
+    description,
+    knowledge_type,
+    level,
+    parent_id,
+    thread_count,
+    consolidation_run_id,
+    created_at,
+    updated_at
+FROM weave.concept_clusters
+WHERE organization_id = $1
+  AND realm_kind = $2
+  AND realm_key = $3
+  AND parent_id = $4
+ORDER BY updated_at DESC, id ASC`;
+async function listConceptClustersByParentAndRealm(client, args) {
+    const result = await client.query({
+        text: exports.listConceptClustersByParentAndRealmQuery,
+        values: [args.organizationId, args.realmKind, args.realmKey, args.parentId],
+        rowMode: "array"
+    });
+    return result.rows.map(row => {
+        return {
+            id: row[0],
+            organizationId: row[1],
+            realmKind: row[2],
+            realmKey: row[3],
+            name: row[4],
+            description: row[5],
+            knowledgeType: row[6],
+            level: row[7],
+            parentId: row[8],
+            threadCount: row[9],
+            consolidationRunId: row[10],
+            createdAt: row[11],
+            updatedAt: row[12]
+        };
+    });
+}
+exports.listApprovedThreadsForConsolidationQuery = `-- name: ListApprovedThreadsForConsolidation :many
+SELECT
+    t.id,
+    t.organization_id,
+    t.document_id,
+    t.ingestion_run_id,
+    t.text,
+    t.knowledge_type,
+    t.embedding::text AS embedding_text,
+    t.approved_at,
+    CASE
+        WHEN d.scope = 'DOCUMENT_SCOPE_ORG'
+            THEN 'KNOWLEDGE_REALM_KIND_ORG'::text
+        WHEN d.scope = 'DOCUMENT_SCOPE_RESTRICTED'
+            THEN 'KNOWLEDGE_REALM_KIND_TAG'::text
+        WHEN d.scope = 'DOCUMENT_SCOPE_PRIVATE'
+            THEN 'KNOWLEDGE_REALM_KIND_USER'::text
+    END AS realm_kind,
+    CASE
+        WHEN d.scope = 'DOCUMENT_SCOPE_ORG'
+            THEN ''::text
+        WHEN d.scope = 'DOCUMENT_SCOPE_RESTRICTED'
+            THEN COALESCE(d.sensitivity_tags[1], ''::text)
+        WHEN d.scope = 'DOCUMENT_SCOPE_PRIVATE'
+            THEN d.uploaded_by_user_id::text
+    END AS realm_key
+FROM weave.threads t
+JOIN weave.documents d ON d.id = t.document_id
+WHERE t.organization_id = $1
+  AND t.retrieval_status = 'THREAD_RETRIEVAL_STATUS_APPROVED'
+  AND t.embedding IS NOT NULL
+ORDER BY t.approved_at DESC, t.id ASC
+LIMIT $3 OFFSET $2`;
+async function listApprovedThreadsForConsolidation(client, args) {
+    const result = await client.query({
+        text: exports.listApprovedThreadsForConsolidationQuery,
+        values: [args.organizationId, args.pageOffset, args.pageSize],
+        rowMode: "array"
+    });
+    return result.rows.map(row => {
+        return {
+            id: row[0],
+            organizationId: row[1],
+            documentId: row[2],
+            ingestionRunId: row[3],
+            text: row[4],
+            knowledgeType: row[5],
+            embeddingText: row[6],
+            approvedAt: row[7],
+            realmKind: row[8],
+            realmKey: row[9]
+        };
+    });
+}
+exports.assignThreadsToClusterQuery = `-- name: AssignThreadsToCluster :execrows
+UPDATE weave.threads AS t
+SET cluster_id = cc.id
+FROM weave.concept_clusters cc,
+     weave.documents d
+WHERE t.organization_id = $1
+  AND t.id = ANY($2::uuid[])
+  AND cc.organization_id = t.organization_id
+  AND cc.id = $3
+  AND d.id = t.document_id
+  AND (
+      (cc.realm_kind = 'KNOWLEDGE_REALM_KIND_ORG'
+          AND cc.realm_key = ''
+          AND d.scope = 'DOCUMENT_SCOPE_ORG')
+      OR (cc.realm_kind = 'KNOWLEDGE_REALM_KIND_TAG'
+          AND d.scope = 'DOCUMENT_SCOPE_RESTRICTED'
+          AND cardinality(d.sensitivity_tags) = 1
+          AND cc.realm_key = d.sensitivity_tags[1])
+      OR (cc.realm_kind = 'KNOWLEDGE_REALM_KIND_USER'
+          AND d.scope = 'DOCUMENT_SCOPE_PRIVATE'
+          AND cc.realm_key = d.uploaded_by_user_id::text)
+  )`;
+exports.clearThreadClusterAssignmentsByOrganizationQuery = `-- name: ClearThreadClusterAssignmentsByOrganization :execrows
+UPDATE weave.threads
+SET cluster_id = NULL
+WHERE organization_id = $1
+  AND cluster_id IS NOT NULL`;

package/dist/weavesql/weavedb/document_security_sql.d.ts

@@ -0,0 +1,128 @@
+import { QueryArrayConfig, QueryArrayResult } from "pg";
+interface Client {
+    query: (config: QueryArrayConfig) => Promise<QueryArrayResult>;
+}
+export declare const setDocumentSecurityQuery = "-- name: SetDocumentSecurity :one\nUPDATE weave.documents\nSET\n    scope = $1,\n    sensitivity_tags = $2,\n    updated_at = now()\nWHERE organization_id = $3\n  AND id = $4\nRETURNING\n    id,\n    organization_id,\n    filename,\n    mime_type,\n    parser_name,\n    fingerprint,\n    storage_ref,\n    status,\n    scope,\n    sensitivity_tags,\n    uploaded_by_user_id,\n    uploaded_at,\n    updated_at,\n    page_count,\n    char_count,\n    metadata";
+export interface SetDocumentSecurityArgs {
+    scope: string;
+    sensitivityTags: string[];
+    organizationId: string;
+    documentId: string;
+}
+export interface SetDocumentSecurityRow {
+    id: string;
+    organizationId: string;
+    filename: string;
+    mimeType: string;
+    parserName: string;
+    fingerprint: Buffer | null;
+    storageRef: string;
+    status: string;
+    scope: string;
+    sensitivityTags: string[];
+    uploadedByUserId: string;
+    uploadedAt: Date;
+    updatedAt: Date;
+    pageCount: number | null;
+    charCount: number | null;
+    metadata: any;
+}
+export declare function setDocumentSecurity(client: Client, args: SetDocumentSecurityArgs): Promise<SetDocumentSecurityRow | null>;
+export declare const upsertOrganizationSensitivityTagQuery = "-- name: UpsertOrganizationSensitivityTag :one\nINSERT INTO weave.org_sensitivity_tags (\n    organization_id,\n    slug,\n    label,\n    description,\n    extraction_hint,\n    active\n) VALUES (\n    $1,\n    $2,\n    $3,\n    $4,\n    $5,\n    $6\n)\nON CONFLICT (organization_id, slug) DO UPDATE\nSET\n    label = EXCLUDED.label,\n    description = EXCLUDED.description,\n    extraction_hint = EXCLUDED.extraction_hint,\n    active = EXCLUDED.active,\n    updated_at = now()\nRETURNING\n    organization_id,\n    slug,\n    label,\n    description,\n    extraction_hint,\n    active,\n    created_at,\n    updated_at";
+export interface UpsertOrganizationSensitivityTagArgs {
+    organizationId: string;
+    slug: string;
+    label: string;
+    description: string;
+    extractionHint: string;
+    active: boolean;
+}
+export interface UpsertOrganizationSensitivityTagRow {
+    organizationId: string;
+    slug: string;
+    label: string;
+    description: string;
+    extractionHint: string;
+    active: boolean;
+    createdAt: Date;
+    updatedAt: Date;
+}
+export declare function upsertOrganizationSensitivityTag(client: Client, args: UpsertOrganizationSensitivityTagArgs): Promise<UpsertOrganizationSensitivityTagRow | null>;
+export declare const listOrganizationSensitivityTagsQuery = "-- name: ListOrganizationSensitivityTags :many\nSELECT\n    organization_id,\n    slug,\n    label,\n    description,\n    extraction_hint,\n    active,\n    created_at,\n    updated_at\nFROM weave.org_sensitivity_tags\nWHERE organization_id = $1\nORDER BY slug ASC";
+export interface ListOrganizationSensitivityTagsArgs {
+    organizationId: string;
+}
+export interface ListOrganizationSensitivityTagsRow {
+    organizationId: string;
+    slug: string;
+    label: string;
+    description: string;
+    extractionHint: string;
+    active: boolean;
+    createdAt: Date;
+    updatedAt: Date;
+}
+export declare function listOrganizationSensitivityTags(client: Client, args: ListOrganizationSensitivityTagsArgs): Promise<ListOrganizationSensitivityTagsRow[]>;
+export declare const listActiveOrganizationSensitivityTagsQuery = "-- name: ListActiveOrganizationSensitivityTags :many\nSELECT\n    organization_id,\n    slug,\n    label,\n    description,\n    extraction_hint,\n    active,\n    created_at,\n    updated_at\nFROM weave.org_sensitivity_tags\nWHERE organization_id = $1\n  AND active = TRUE\nORDER BY slug ASC";
+export interface ListActiveOrganizationSensitivityTagsArgs {
+    organizationId: string;
+}
+export interface ListActiveOrganizationSensitivityTagsRow {
+    organizationId: string;
+    slug: string;
+    label: string;
+    description: string;
+    extractionHint: string;
+    active: boolean;
+    createdAt: Date;
+    updatedAt: Date;
+}
+export declare function listActiveOrganizationSensitivityTags(client: Client, args: ListActiveOrganizationSensitivityTagsArgs): Promise<ListActiveOrganizationSensitivityTagsRow[]>;
+export declare const deactivateOrganizationSensitivityTagQuery = "-- name: DeactivateOrganizationSensitivityTag :one\nUPDATE weave.org_sensitivity_tags\nSET\n    active = FALSE,\n    updated_at = now()\nWHERE organization_id = $1\n  AND slug = $2\nRETURNING\n    organization_id,\n    slug,\n    label,\n    description,\n    extraction_hint,\n    active,\n    created_at,\n    updated_at";
+export interface DeactivateOrganizationSensitivityTagArgs {
+    organizationId: string;
+    slug: string;
+}
+export interface DeactivateOrganizationSensitivityTagRow {
+    organizationId: string;
+    slug: string;
+    label: string;
+    description: string;
+    extractionHint: string;
+    active: boolean;
+    createdAt: Date;
+    updatedAt: Date;
+}
+export declare function deactivateOrganizationSensitivityTag(client: Client, args: DeactivateOrganizationSensitivityTagArgs): Promise<DeactivateOrganizationSensitivityTagRow | null>;
+export declare const grantUserSensitivityClearanceQuery = "-- name: GrantUserSensitivityClearance :one\nINSERT INTO weave.user_sensitivity_clearances (\n    organization_id,\n    user_id,\n    sensitivity_tag_slug\n) VALUES (\n    $1,\n    $2,\n    $3\n)\nON CONFLICT (organization_id, user_id, sensitivity_tag_slug) DO UPDATE\nSET\n    sensitivity_tag_slug = EXCLUDED.sensitivity_tag_slug\nRETURNING\n    organization_id,\n    user_id,\n    sensitivity_tag_slug,\n    created_at";
+export interface GrantUserSensitivityClearanceArgs {
+    organizationId: string;
+    userId: string;
+    sensitivityTagSlug: string;
+}
+export interface GrantUserSensitivityClearanceRow {
+    organizationId: string;
+    userId: string;
+    sensitivityTagSlug: string;
+    createdAt: Date;
+}
+export declare function grantUserSensitivityClearance(client: Client, args: GrantUserSensitivityClearanceArgs): Promise<GrantUserSensitivityClearanceRow | null>;
+export declare const revokeUserSensitivityClearanceQuery = "-- name: RevokeUserSensitivityClearance :execrows\nDELETE FROM weave.user_sensitivity_clearances\nWHERE organization_id = $1\n  AND user_id = $2\n  AND sensitivity_tag_slug = $3";
+export interface RevokeUserSensitivityClearanceArgs {
+    organizationId: string;
+    userId: string;
+    sensitivityTagSlug: string;
+}
+export declare const listUserSensitivityClearancesQuery = "-- name: ListUserSensitivityClearances :many\nSELECT\n    organization_id,\n    user_id,\n    sensitivity_tag_slug,\n    created_at\nFROM weave.user_sensitivity_clearances\nWHERE organization_id = $1\n  AND user_id = $2\nORDER BY sensitivity_tag_slug ASC";
+export interface ListUserSensitivityClearancesArgs {
+    organizationId: string;
+    userId: string;
+}
+export interface ListUserSensitivityClearancesRow {
+    organizationId: string;
+    userId: string;
+    sensitivityTagSlug: string;
+    createdAt: Date;
+}
+export declare function listUserSensitivityClearances(client: Client, args: ListUserSensitivityClearancesArgs): Promise<ListUserSensitivityClearancesRow[]>;
+export {};