@axiom-lattice/pg-stores 1.0.80 → 1.0.82

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@axiom-lattice/pg-stores",
-  "version": "1.0.80",
+  "version": "1.0.82",
   "description": "PG stores implementation for Axiom Lattice framework",
   "main": "dist/index.js",
   "module": "dist/index.mjs",
@@ -23,8 +23,8 @@
     "@langchain/langgraph-checkpoint-postgres": "1.0.0",
     "pg": "^8.16.3",
     "uuid": "^9.0.1",
-    "@axiom-lattice/core": "2.1.89",
-    "@axiom-lattice/protocols": "2.1.44"
+    "@axiom-lattice/core": "2.1.91",
+    "@axiom-lattice/protocols": "2.1.46"
   },
   "devDependencies": {
     "@types/node": "^20.11.24",

package/src/createPgStoreConfig.ts

@@ -17,6 +17,7 @@ import { PostgreSQLA2AApiKeyStore } from "./stores/PostgreSQLA2AApiKeyStore";
 import { PostgreSQLScheduleStorage } from "./stores/PostgreSQLScheduleStorage";
 import { PostgreSQLTaskStore } from "./stores/PostgreSQLTaskStore";
 import { MenuStore } from "./stores/MenuStore";
+import { PostgresSharedResourceStore } from "./stores/PostgresSharedResourceStore";
 import { PostgresSaver } from "@langchain/langgraph-checkpoint-postgres";
 
 export function createPgStoreConfig(connectionString: string) {
@@ -47,6 +48,7 @@ export function createPgStoreConfig(connectionString: string) {
     a2aApiKey: new PostgreSQLA2AApiKeyStore(opts),
     schedule: new PostgreSQLScheduleStorage(opts),
     menu: new MenuStore(opts),
+    sharedResource: new PostgresSharedResourceStore(opts),
     checkpoint,
   };
 }

package/src/index.ts

@@ -47,6 +47,7 @@ export * from "./migrations/channel_identity_mapping_migration";
 export * from "./migrations/channel_installation_migrations";
 export * from "./migrations/channel_installations_alter_migration";
 export * from "./migrations/channel_bindings_migration";
+export * from "./migrations/shared_resources_migration";
 export * from "./migrations/a2a_api_key_migration";
 export * from "./migrations/workflow_tracking_migrations";
 export * from "./stores/ChannelBindingStore";
@@ -58,7 +59,10 @@ export * from "./stores/PostgreSQLWorkflowTrackingStore";
 export * from "./stores/PostgreSQLEvalStore";
 export * from "./migrations/eval_migrations";
 export * from "./migrations/menu_items_migration";
+export * from "./migrations/menu_items_add_file_type";
 export * from "./stores/MenuStore";
+export * from "./stores/SharedResourceStore";
+export * from "./stores/PostgresSharedResourceStore";
 
 // Re-export for convenience
 export { PostgreSQLThreadStore } from "./stores/PostgreSQLThreadStore";
@@ -80,6 +84,7 @@ export { PostgreSQLChannelInstallationStore } from "./stores/PostgreSQLChannelIn
 export { PostgreSQLA2AApiKeyStore } from "./stores/PostgreSQLA2AApiKeyStore";
 export { PostgreSQLWorkflowTrackingStore } from "./stores/PostgreSQLWorkflowTrackingStore";
 export { PostgreSQLEvalStore } from "./stores/PostgreSQLEvalStore";
+export { PostgresSharedResourceStore } from "./stores/PostgresSharedResourceStore";
 
 // Re-export types from protocols
 export type {
@@ -163,4 +168,9 @@ export type {
   CreateEvalRunRequest,
   EvalRunResult,
   EvalProjectReport,
+  ShareRecord,
+  ResourceAddress,
+  ShareVisibility,
+  CreateShareRequest,
+  ShareResult,
 } from "@axiom-lattice/protocols";

package/src/migrations/menu_items_add_file_type.ts

@@ -0,0 +1,29 @@
+import { PoolClient } from "pg";
+import { Migration } from "./migration";
+
+export const addFileContentType: Migration = {
+  version: 136,
+  name: "add_file_content_type_to_menu_items",
+  up: async (client: PoolClient) => {
+    await client.query(`
+      ALTER TABLE lattice_menu_items
+      DROP CONSTRAINT IF EXISTS lattice_menu_items_content_type_check
+    `);
+    await client.query(`
+      ALTER TABLE lattice_menu_items
+      ADD CONSTRAINT lattice_menu_items_content_type_check
+      CHECK (content_type IN ('agent', 'html', 'custom', 'file'))
+    `);
+  },
+  down: async (client: PoolClient) => {
+    await client.query(`
+      ALTER TABLE lattice_menu_items
+      DROP CONSTRAINT IF EXISTS lattice_menu_items_content_type_check
+    `);
+    await client.query(`
+      ALTER TABLE lattice_menu_items
+      ADD CONSTRAINT lattice_menu_items_content_type_check
+      CHECK (content_type IN ('agent', 'html', 'custom'))
+    `);
+  },
+};

package/src/migrations/menu_items_migration.ts

@@ -14,7 +14,7 @@ export const createMenuItemsTable: Migration = {
         name VARCHAR(255) NOT NULL,
         icon VARCHAR(50),
         sort_order INT NOT NULL DEFAULT 0,
-        content_type VARCHAR(20) NOT NULL CHECK (content_type IN ('agent', 'html', 'custom')),
+         content_type VARCHAR(20) NOT NULL CHECK (content_type IN ('agent', 'html', 'custom', 'file')),
         content_config JSONB NOT NULL DEFAULT '{}',
         enabled BOOLEAN NOT NULL DEFAULT true,
         created_at TIMESTAMP NOT NULL DEFAULT NOW(),

package/src/migrations/shared_resources_migration.ts

@@ -0,0 +1,43 @@
+import { PoolClient } from "pg";
+import { Migration } from "./migration";
+
+export const createSharedResourcesTable: Migration = {
+  version: 135,
+  name: "create_shared_resources_table",
+  up: async (client: PoolClient) => {
+    await client.query(`
+      CREATE TABLE IF NOT EXISTS lattice_shared_resources (
+        token         VARCHAR(64) PRIMARY KEY,
+        address       JSONB NOT NULL,
+        title         VARCHAR(256),
+        created_by    VARCHAR(64) NOT NULL,
+        tenant_id     VARCHAR(64) NOT NULL,
+        workspace_id  VARCHAR(64) NOT NULL,
+        project_id    VARCHAR(64) NOT NULL,
+        assistant_id  VARCHAR(64),
+        vm_isolation  VARCHAR(16) NOT NULL DEFAULT 'project',
+        visibility    VARCHAR(16) NOT NULL DEFAULT 'public',
+        password_hash VARCHAR(128),
+        expires_at    TIMESTAMPTZ,
+        max_access    INT,
+        access_count  INT DEFAULT 0,
+        revoked       BOOLEAN DEFAULT FALSE,
+        created_at    TIMESTAMPTZ DEFAULT NOW(),
+        version       INT DEFAULT 1
+      )
+    `);
+
+    await client.query(`
+      CREATE INDEX IF NOT EXISTS idx_shared_resources_tenant
+      ON lattice_shared_resources(tenant_id)
+    `);
+
+    await client.query(`
+      CREATE INDEX IF NOT EXISTS idx_shared_resources_user
+      ON lattice_shared_resources(created_by)
+    `);
+  },
+  down: async (client: PoolClient) => {
+    await client.query("DROP TABLE IF EXISTS lattice_shared_resources");
+  },
+};

package/src/stores/MenuStore.ts

@@ -9,6 +9,7 @@ import type {
 } from "@axiom-lattice/protocols";
 import { MigrationManager } from "../migrations/migration";
 import { createMenuItemsTable } from "../migrations/menu_items_migration";
+import { addFileContentType } from "../migrations/menu_items_add_file_type";
 
 export interface MenuStoreOptions {
   poolConfig: string | PoolConfig;
@@ -44,6 +45,7 @@ export class MenuStore implements MenuRegistry {
 
     this.migrationManager = new MigrationManager(this.pool);
     this.migrationManager.register(createMenuItemsTable);
+    this.migrationManager.register(addFileContentType);
 
     if (options.autoMigrate !== false) {
       this.initialize().catch((error) => {

package/src/stores/PostgresSharedResourceStore.ts

@@ -0,0 +1,220 @@
+import { Pool } from "pg";
+import type { PoolConfig } from "pg";
+import type { ShareRecord, ResourceAddress } from "@axiom-lattice/protocols";
+import type { SharedResourceStore } from "./SharedResourceStore";
+import { MigrationManager } from "../migrations/migration";
+import { createSharedResourcesTable } from "../migrations/shared_resources_migration";
+
+export interface PostgresSharedResourceStoreOptions {
+  poolConfig: string | PoolConfig;
+  autoMigrate?: boolean;
+}
+
+type ShareRow = {
+  token: string;
+  address: ResourceAddress;
+  title: string | null;
+  created_by: string;
+  tenant_id: string;
+  workspace_id: string;
+  project_id: string;
+  assistant_id: string | null;
+  vm_isolation: string;
+  visibility: string;
+  password_hash: string | null;
+  expires_at: string | null;
+  max_access: number | null;
+  access_count: number;
+  revoked: boolean;
+  created_at: string;
+  version: number;
+};
+
+export class PostgresSharedResourceStore implements SharedResourceStore {
+  private pool: Pool;
+  private migrationManager: MigrationManager;
+  private initialized = false;
+  private initPromise: Promise<void> | null = null;
+
+  constructor(options: PostgresSharedResourceStoreOptions) {
+    this.pool =
+      typeof options.poolConfig === "string"
+        ? new Pool({ connectionString: options.poolConfig })
+        : new Pool(options.poolConfig);
+
+    this.migrationManager = new MigrationManager(this.pool);
+    this.migrationManager.register(createSharedResourcesTable);
+
+    if (options.autoMigrate !== false) {
+      this.initialize().catch((error) => {
+        console.error(
+          "Failed to initialize PostgresSharedResourceStore:",
+          error,
+        );
+        throw error;
+      });
+    }
+  }
+
+  async initialize(): Promise<void> {
+    if (this.initialized) return;
+    if (this.initPromise) return this.initPromise;
+    this.initPromise = (async () => {
+      try {
+        await this.migrationManager.migrate();
+        this.initialized = true;
+      } finally {
+        this.initPromise = null;
+      }
+    })();
+    return this.initPromise;
+  }
+
+  async findByToken(token: string): Promise<ShareRecord | null> {
+    await this.ensureInitialized();
+    const { rows } = await this.pool.query<ShareRow>(
+      "SELECT * FROM lattice_shared_resources WHERE token = $1",
+      [token],
+    );
+    if (rows.length === 0) return null;
+    return this._mapRow(rows[0]);
+  }
+
+  async create(
+    record: Omit<ShareRecord, "accessCount" | "createdAt" | "version">,
+  ): Promise<ShareRecord> {
+    await this.ensureInitialized();
+    const { rows } = await this.pool.query<ShareRow>(
+      `INSERT INTO lattice_shared_resources
+       (token, address, title, created_by, tenant_id, workspace_id, project_id,
+        assistant_id, vm_isolation, visibility, password_hash,
+        expires_at, max_access, revoked)
+       VALUES ($1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,$13,$14)
+       RETURNING *`,
+      [
+        record.token,
+        JSON.stringify(record.address),
+        record.title,
+        record.createdBy,
+        record.tenantId,
+        record.workspaceId,
+        record.projectId,
+        record.assistantId,
+        record.vmIsolation,
+        record.visibility,
+        record.passwordHash,
+        record.expiresAt ? record.expiresAt.toISOString() : null,
+        record.maxAccess,
+        record.revoked,
+      ],
+    );
+    return this._mapRow(rows[0]);
+  }
+
+  async update(
+    token: string,
+    patch: Record<string, unknown>,
+  ): Promise<void> {
+    await this.ensureInitialized();
+    const ALLOWED_COLUMNS = new Set([
+      "title", "expiresAt", "maxAccess", "revoked", "visibility", "passwordHash",
+    ]);
+    const COLUMN_MAP: Record<string, string> = {
+      "title": "title",
+      "expiresAt": "expires_at",
+      "maxAccess": "max_access",
+      "revoked": "revoked",
+      "visibility": "visibility",
+      "passwordHash": "password_hash",
+    };
+
+    const sets: string[] = [];
+    const vals: unknown[] = [];
+    let i = 1;
+
+    for (const [col, val] of Object.entries(patch)) {
+      const dbCol = COLUMN_MAP[col];
+      if (dbCol && val !== undefined) {
+        sets.push(`${dbCol} = $${i++}`);
+        vals.push(val);
+      }
+    }
+    if (sets.length === 0) return;
+
+    vals.push(token);
+    await this.pool.query(
+      `UPDATE lattice_shared_resources SET ${sets.join(", ")} WHERE token = $${i}`,
+      vals,
+    );
+  }
+
+  async listByUser(
+    tenantId: string,
+    userId: string,
+  ): Promise<ShareRecord[]> {
+    await this.ensureInitialized();
+    const { rows } = await this.pool.query<ShareRow>(
+      `SELECT * FROM lattice_shared_resources
+       WHERE tenant_id = $1 AND created_by = $2
+       ORDER BY created_at DESC`,
+      [tenantId, userId],
+    );
+    return rows.map((r) => this._mapRow(r));
+  }
+
+  async incrementAccess(token: string): Promise<void> {
+    await this.ensureInitialized();
+    await this.pool.query(
+      "UPDATE lattice_shared_resources SET access_count = access_count + 1 WHERE token = $1",
+      [token],
+    );
+  }
+
+  async atomicIncrementAccess(token: string): Promise<boolean> {
+    await this.ensureInitialized();
+    const { rows } = await this.pool.query(
+      `UPDATE lattice_shared_resources SET access_count = access_count + 1
+       WHERE token = $1 AND NOT revoked
+         AND (expires_at IS NULL OR expires_at > NOW())
+         AND (max_access IS NULL OR access_count < max_access)
+       RETURNING 1`,
+      [token],
+    );
+    return rows.length > 0;
+  }
+
+  private async ensureInitialized(): Promise<void> {
+    if (!this.initialized) {
+      await this.initialize();
+    }
+  }
+
+  private _mapRow(row: ShareRow): ShareRecord {
+    let address: ResourceAddress;
+    if (typeof row.address === "string") {
+      address = JSON.parse(row.address) as ResourceAddress;
+    } else {
+      address = row.address as ResourceAddress;
+    }
+
+    return {
+      token: row.token,
+      address,
+      title: row.title,
+      createdBy: row.created_by,
+      tenantId: row.tenant_id,
+      workspaceId: row.workspace_id,
+      projectId: row.project_id,
+      assistantId: row.assistant_id,
+      vmIsolation: row.vm_isolation,
+      visibility: row.visibility as ShareRecord["visibility"],
+      passwordHash: row.password_hash,
+      expiresAt: row.expires_at ? new Date(row.expires_at) : null,
+      maxAccess: row.max_access,
+      accessCount: row.access_count ?? 0,
+      revoked: row.revoked ?? false,
+      createdAt: new Date(row.created_at),
+      version: row.version ?? 1,
+    };
+  }
+}

package/src/stores/SharedResourceStore.ts

@@ -0,0 +1 @@
+export type { SharedResourceStore } from "@axiom-lattice/protocols";