@asaidimu/hestia 1.0.0 → 1.0.1

package/system/policies/store.ts

@@ -1,74 +1,177 @@
 import type { QueryDSL } from "@asaidimu/query"
 import { HestiaNetworkClient } from "../../core/client"
-import { HestiaCollection } from "../../core/collection"
-import type { Document, Page } from "../../core/types"
+import { ReactiveDataStore } from "@asaidimu/utils-store"
+import { createPagedController } from "../../core/pager"
+import type { Document, Page, PagedData, PaginationInfo, StoreEvent } from "../../core/types"
+import type { DocumentStore } from "../../core/types"
 import type {
-    PolicyOperation,
-    PolicyRule,
+    OperationPolicy,
+    IamRule,
     UpsertOperationRequest,
     UpsertRuleRequest,
+    ReloadResult,
 } from "./types"
 
-export class HestiaPolicies {
-  private operations: HestiaCollection<PolicyOperation>
-  private rules: HestiaCollection<PolicyRule>
+const OPERATIONS_COLLECTION = "_operation_policy_"
+const RULES_COLLECTION = "_iam_rule_"
+
+export class HestiaPolicies implements DocumentStore<OperationPolicy, QueryDSL<OperationPolicy>, string, QueryDSL<OperationPolicy>, Record<string, unknown>, string, string, Record<string, unknown>> {
+  private pager: PagedData<OperationPolicy>
+  private operationsPath = "/system/policies/operation"
+  private rulesPath = "/system/policies/rule"
 
   constructor(private client: HestiaNetworkClient) {
-    this.operations = new HestiaCollection<PolicyOperation>(client, "_policy_operation_")
-    this.rules = new HestiaCollection<PolicyRule>(client, "_policy_rule_")
+    this.pager = createPagedController<OperationPolicy>(
+      "policies",
+      new ReactiveDataStore<any>({}),
+      {},
+      (query) => this.find(query),
+    )
   }
 
-  // ── Operations ──
+  private async collectionQuery<T extends Record<string, any>>(
+    collection: string,
+    query?: Record<string, unknown>,
+  ): Promise<Page<T>> {
+    const res = await this.client.post<{
+      data: Document<T>[];
+      metadata?: { page?: PaginationInfo };
+    }>(`/system/collections/document/${encodeURIComponent(collection)}/query`, query ?? {})
+    const items = res.data?.data ?? []
+    const pageMeta = res.data?.metadata?.page ?? {
+      number: 1,
+      size: items.length,
+      count: items.length,
+      total: items.length,
+      pages: 1,
+    }
+    return { data: items, loading: false, page: pageMeta, error: null }
+  }
 
-  async findOperations(query?: QueryDSL<PolicyOperation>): Promise<Page<PolicyOperation>> {
-    return this.operations.find(query)
+  async find(query?: QueryDSL<OperationPolicy>): Promise<Page<OperationPolicy>> {
+    return this.collectionQuery<OperationPolicy>(OPERATIONS_COLLECTION, query as Record<string, unknown> | undefined)
   }
 
-  async listOperations(): Promise<Page<PolicyOperation>> {
-    return this.operations.find({ pagination: { type: "offset", offset: 0, limit: 50 } })
+  async list(options?: QueryDSL<OperationPolicy>): Promise<Page<OperationPolicy>> {
+    return this.find(options ?? { pagination: { type: "offset", offset: 0, limit: 50 } })
   }
 
-  async readOperation(name: string): Promise<Document<PolicyOperation> | undefined> {
-    return this.operations.read(name)
+  async read(id: string): Promise<Document<OperationPolicy> | undefined> {
+    try {
+      const res = await this.client.get<{ data: Document<OperationPolicy> }>(
+        `${this.operationsPath}/${encodeURIComponent(id)}`,
+      )
+      return res.data?.data
+    } catch (err: any) {
+      if (err?.code === "SYNC-001-NF" || err?.code === "NOT_FOUND" || err?.code === "INTERNAL_ERROR" && typeof err?.message === "string" && err.message.includes("not found")) return undefined
+      throw err
+    }
   }
 
-  async createOperation(data: UpsertOperationRequest): Promise<Document<PolicyOperation>> {
-    return this.operations.create(data as any)
+  async create(props: { data: Partial<OperationPolicy> }): Promise<Document<OperationPolicy> | undefined> {
+    const name = props.data.name
+    if (!name) throw new Error("Operation name is required for create")
+    const res = await this.client.patch<{ data: Document<OperationPolicy> }>(
+      `${this.operationsPath}/${encodeURIComponent(name)}`,
+      props.data as UpsertOperationRequest,
+    )
+    return res.data!.data
   }
 
-  async updateOperation(name: string, data: UpsertOperationRequest): Promise<Document<PolicyOperation>> {
-    return this.operations.update(name, data as any)
+  async update(props: { data: Partial<OperationPolicy>; options?: string }): Promise<Document<OperationPolicy> | undefined> {
+    const name = props.options!
+    if (!name) throw new Error("Operation name is required for update")
+    const res = await this.client.patch<{ data: Document<OperationPolicy> }>(
+      `${this.operationsPath}/${encodeURIComponent(name)}`,
+      props.data as UpsertOperationRequest,
+    )
+    return res.data!.data
   }
 
-  async deleteOperation(name: string): Promise<void> {
-    return this.operations.delete(name)
+  async delete(id: string): Promise<void> {
+    await this.client.delete(`${this.operationsPath}/${encodeURIComponent(id)}`)
   }
 
-  // ── Rules ──
+  async upsertOperation(
+    name: string,
+    data: UpsertOperationRequest,
+  ): Promise<Document<OperationPolicy>> {
+    const res = await this.client.patch<{ data: Document<OperationPolicy> }>(
+      `${this.operationsPath}/${encodeURIComponent(name)}`,
+      data,
+    )
+    return res.data!.data
+  }
 
-  async findRules(query?: QueryDSL<PolicyRule>): Promise<Page<PolicyRule>> {
-    return this.rules.find(query)
+  async getRule(name: string): Promise<Document<IamRule> | undefined> {
+    try {
+      const res = await this.client.get<{ data: Document<IamRule> }>(
+        `${this.rulesPath}/${encodeURIComponent(name)}`,
+      )
+      return res.data?.data
+    } catch (err: any) {
+      if (err?.code === "SYNC-001-NF" || err?.code === "NOT_FOUND" || err?.code === "INTERNAL_ERROR" && typeof err?.message === "string" && err.message.includes("not found")) return undefined
+      throw err
+    }
   }
 
-  async listRules(): Promise<Page<PolicyRule>> {
-    return this.rules.find({ pagination: { type: "offset", offset: 0, limit: 50 } })
+  async upsertRule(
+    name: string,
+    data: UpsertRuleRequest,
+  ): Promise<Document<IamRule>> {
+    const res = await this.client.patch<{ data: Document<IamRule> }>(
+      `${this.rulesPath}/${encodeURIComponent(name)}`,
+      data,
+    )
+    return res.data!.data
   }
 
-  async readRule(name: string): Promise<Document<PolicyRule> | undefined> {
-    return this.rules.read(name)
+  async deleteRule(name: string): Promise<void> {
+    await this.client.delete(`${this.rulesPath}/${encodeURIComponent(name)}`)
   }
 
-  async createRule(data: UpsertRuleRequest): Promise<Document<PolicyRule>> {
-    return this.rules.create(data as any)
+  async listRules(options?: Record<string, unknown>): Promise<Page<IamRule>> {
+    return this.collectionQuery<IamRule>(RULES_COLLECTION, options)
   }
 
-  async updateRule(name: string, data: UpsertRuleRequest): Promise<Document<PolicyRule>> {
-    return this.rules.update(name, data as any)
+  async validateRule(
+    expression: string,
+  ): Promise<boolean> {
+    const res = await this.client.post<{ data: { valid: boolean } }>(
+      `${this.rulesPath}/validate`,
+      { expression },
+    )
+    return res.data?.data?.valid ?? false
   }
 
-  async deleteRule(name: string): Promise<void> {
-    return this.rules.delete(name)
+  async reload(): Promise<ReloadResult> {
+    const res = await this.client.get<{ data: ReloadResult }>(
+      `${this.rulesPath}/reload`,
+    )
+    return res.data!.data
   }
 
+  async upload(_props: { file: File }): Promise<Document<OperationPolicy> | undefined> {
+    throw new Error("Upload not supported for policies")
+  }
 
+  async subscribe(_scope: string, _callback: (event: StoreEvent) => void): Promise<() => void> {
+    throw new Error("Subscription not supported for policies")
+  }
+
+  async notify(_event: StoreEvent): Promise<void> {
+    throw new Error("Notify not supported for policies")
+  }
+
+  stream(_options: Record<string, unknown>, _onStreamChange: () => void): {
+    stream: () => AsyncIterable<Document<OperationPolicy>>;
+    cancel: () => void;
+    status: () => "active" | "cancelled" | "completed";
+  } {
+    throw new Error("Stream not supported for policies")
+  }
+
+  page(_options?: Record<string, unknown>): PagedData<OperationPolicy> {
+    return this.pager
+  }
 }

package/system/policies/types.ts

@@ -1,4 +1,4 @@
-export interface PolicyOperation {
+export interface OperationPolicy {
   name: string
   ruleKey: string
   description?: string
@@ -11,7 +11,7 @@ export interface UpsertOperationRequest {
   intentType?: "COMMAND" | "QUERY"
 }
 
-export interface PolicyRule {
+export interface IamRule {
   name: string
   ruleType?: string
   expression?: string

package/utils/pager.ts

@@ -1,6 +1,7 @@
-import { QueryDSL, QueryFilter, SortConfiguration, createMatcher, createSorter } from '@asaidimu/query'; //
+import { createMatcher, createSorter } from '@asaidimu/query'; //
+import type { QueryDSL, QueryFilter, SortConfiguration } from '@asaidimu/query'; //
 import { DELETE_SYMBOL, ReactiveDataStore } from "@asaidimu/utils-store"; //
-import { Page, PagedData } from '../core/types';
+import type { Page, PagedData, PagerRefreshOptions } from '../core/types';
 
 export interface FetchResult<T extends Record<string, any>> {
   data: T[];
@@ -168,6 +169,7 @@ export function createArrayPager<T extends Record<string, any>, F = any>(
   executeDataPipeline(true);
 
   return {
+    id: () => CACHE_KEY,
     page: () => selector.get() ?? sentinel, //
 
     navigate: async (page: number) => {
@@ -195,15 +197,17 @@ export function createArrayPager<T extends Record<string, any>, F = any>(
       await executeDataPipeline(true);
     },
 
-    refresh: async (delay: number = 600) => { //
+    refresh: async (opts?: PagerRefreshOptions) => { //
       const previousState = selector.get() ?? sentinel;
       await store.set({
         [CACHE_KEY]: { ...previousState, loading: true } //
       });
 
+      const delay = opts?.delay ?? 600;
+
       await Promise.all([
         new Promise((resolve) => setTimeout(resolve, delay)), //
-        executeDataPipeline(false) // Handle full resolution pipeline passing down false to bypass flashing double mutations
+        executeDataPipeline(false) // Handle full resolution pipeline passing down false to avoid flashing double mutations
       ]);
 
       const finishedState = selector.get() ?? sentinel;

package/system/logs/store.ts

@@ -1,147 +0,0 @@
-import type { QueryDSL } from "@asaidimu/query"
-import { HestiaNetworkClient } from "../../core/client"
-import type { Page, PaginationInfo } from "../../core/types"
-import type { AuditEntry } from "./types"
-
-interface FindEnvelope {
-  data: AuditEntry[]
-  metadata?: { page?: PaginationInfo }
-}
-
-interface StreamDoc {
-  data: AuditEntry
-}
-
-export class HestiaLogs {
-  constructor(
-    private client: HestiaNetworkClient,
-    private baseUrl: string,
-  ) {}
-
-  async find(query?: QueryDSL<AuditEntry>): Promise<Page<AuditEntry>> {
-    const res = await this.client.post<FindEnvelope>(
-      "/system/audit/log/query",
-      { query: query ?? {} },
-    )
-
-    const items = res.data?.data ?? []
-    const pageMeta = res.data?.metadata?.page ?? {
-      number: 1,
-      size: items.length,
-      count: items.length,
-      total: items.length,
-      pages: 1,
-    }
-
-    return { data: items, loading: false, page: pageMeta, error: null }
-  }
-
-  async list(): Promise<Page<AuditEntry>> {
-    return this.find({
-      pagination: { type: "offset", offset: 0, limit: 20 },
-    })
-  }
-
-  getStreamUrl(): string {
-    return `${this.baseUrl}/system/audit/log/stream`
-  }
-
-  subscribe(onEntry: (entry: AuditEntry) => void): () => void {
-    const url = this.getStreamUrl()
-    const eventSource = new EventSource(url, { withCredentials: true })
-
-    eventSource.onmessage = (event) => {
-      try {
-        const parsed = JSON.parse(event.data) as StreamDoc
-        if (parsed?.data) {
-          onEntry(parsed.data)
-        }
-      } catch {
-        // skip non-JSON lines
-      }
-    }
-
-    eventSource.onerror = () => {
-      eventSource.close()
-    }
-
-    return () => {
-      eventSource.close()
-    }
-  }
-
-  stream(): {
-    stream: () => AsyncIterable<AuditEntry>
-    cancel: () => void
-    status: () => "active" | "cancelled" | "completed"
-  } {
-    const url = this.getStreamUrl()
-    let eventSource: EventSource | null = null
-    let currentStatus: "active" | "cancelled" | "completed" = "active"
-    let pendingResolve: (() => void) | null = null
-
-    const asyncStream = async function* () {
-      const pending: AuditEntry[] = []
-
-      eventSource = new EventSource(url, { withCredentials: true })
-
-      eventSource.onmessage = (event) => {
-        for (const line of event.data.split("\n")) {
-          const trimmed = line.trim()
-          if (!trimmed) continue
-          try {
-            const parsed = JSON.parse(trimmed) as StreamDoc
-            if (parsed?.data) pending.push(parsed.data)
-          } catch {
-            // skip non-JSON lines
-          }
-        }
-        if (pending.length > 0 && pendingResolve) {
-          pendingResolve()
-          pendingResolve = null
-        }
-      }
-
-      eventSource.onerror = () => {
-        if (currentStatus === "active") currentStatus = "completed"
-        if (pendingResolve) {
-          pendingResolve()
-          pendingResolve = null
-        }
-      }
-
-      try {
-        while (currentStatus === "active") {
-          if (pending.length > 0) {
-            yield pending.shift()!
-          } else {
-            await new Promise<void>((resolve) => {
-              pendingResolve = resolve
-              if (pending.length > 0) {
-                resolve()
-                pendingResolve = null
-              }
-            })
-          }
-        }
-      } finally {
-        eventSource?.close()
-        if (pendingResolve) {
-          pendingResolve()
-          pendingResolve = null
-        }
-        if (currentStatus === "active") currentStatus = "completed"
-      }
-    }
-
-    return {
-      stream: () => asyncStream(),
-      cancel: () => {
-        if (currentStatus !== "active") return
-        currentStatus = "cancelled"
-        eventSource?.close()
-      },
-      status: () => currentStatus,
-    }
-  }
-}

package/system/logs/types.ts

@@ -1,38 +0,0 @@
-export interface AuditEntry {
-  event_id: string
-  occurred_at: string
-  recorded_at: string
-  trace_id?: string
-  request_id?: string
-  actor_id: string
-  actor_type: "user" | "service" | "system" | "anonymous"
-  on_behalf_of_id?: string
-  auth_method?: "password" | "oauth" | "api_key" | "mtls" | "sso" | "service_account" | "none"
-  session_id?: string
-  operation: "create" | "read" | "update" | "delete" | "login" | "logout" | "grant" | "revoke" | "execute" | "other"
-  resource_type: string
-  resource_id?: string
-  event_name: string
-  status: "success" | "failure" | "denied" | "error"
-  severity?: "info" | "warning" | "critical"
-  error_code?: string
-  error_message?: string
-  latency_ms: number
-  source_ip?: string
-  user_agent?: string
-  service_name: string
-  region?: string
-}
-
-export type RequestLogEntry = AuditEntry
-
-export interface LogFilter {
-  actor_id?: string
-  actor_type?: string
-  operation?: string
-  status?: string
-  resource_type?: string
-  trace_id?: string
-  start?: string
-  end?: string
-}