@asaidimu/hestia 1.0.0 → 1.0.1

package/core/collection.ts

@@ -9,6 +9,7 @@ import type {
     PaginationInfo,
     StoreEvent,
 } from "./types";
+import type { DocumentStore } from "./types";
 
 interface ServerEnvelope<T extends Record<string, any>> {
   data: Document<T>[];
@@ -19,19 +20,20 @@ interface SingleEnvelope<T extends Record<string, any>> {
   data: Document<T>;
 }
 
-export class HestiaCollection<T extends Record<string, any>> {
+export class HestiaCollection<T extends Record<string, any>> implements DocumentStore<T, Record<string, unknown>, string, Record<string, unknown>, Record<string, unknown>, string, string, Record<string, unknown>> {
   private pagerOptions: PageOptions<T> = {};
   private pager: PagedData<T>;
 
   constructor(
     private client: HestiaNetworkClient,
     private collectionName: string,
+    private defaultLimit: number = 50,
   ) {
     this.pager = createPagedController<T>(
       collectionName,
       new ReactiveDataStore<any>({}),
       this.pagerOptions,
-      (query) => this.find(query),
+      (query) => this.find(query as any),
     );
   }
 
@@ -51,7 +53,7 @@ export class HestiaCollection<T extends Record<string, any>> {
     return `${this.documentsPath}/${encodeURIComponent(id)}`;
   }
 
-  async find(query?: QueryDSL<T>): Promise<Page<T>> {
+  async find(query?: Record<string, unknown>): Promise<Page<T>> {
     const res = await this.client.post<ServerEnvelope<T>>(
       this.queryPath,
       query ?? {},
@@ -82,18 +84,19 @@ export class HestiaCollection<T extends Record<string, any>> {
     }
   }
 
-  async create(data: Partial<T>): Promise<Document<T>> {
+  async create(props: { data: Partial<T> }): Promise<Document<T> | undefined> {
     const res = await this.client.post<SingleEnvelope<T>>(
       this.documentsPath,
-      data,
+      props.data,
     );
     return res.data!.data;
   }
 
-  async update(id: string, data: Partial<T>): Promise<Document<T>> {
+  async update(props: { data: Partial<T>; options?: string }): Promise<Document<T> | undefined> {
+    const id = props.options!;
     const res = await this.client.patch<SingleEnvelope<T>>(
       this.documentPath(id),
-      data,
+      props.data,
     );
     return res.data!.data;
   }
@@ -102,6 +105,16 @@ export class HestiaCollection<T extends Record<string, any>> {
     await this.client.delete(this.documentPath(id));
   }
 
+  async list(options?: Record<string, unknown>): Promise<Page<T>> {
+    return this.find(
+      options ?? { pagination: { type: "offset", offset: 0, limit: this.defaultLimit } },
+    );
+  }
+
+  async upload(_props: { file: File }): Promise<Document<T> | undefined> {
+    throw new Error("Upload not supported for collections");
+  }
+
   async subscribe(
     _scope: string,
     _callback: (event: StoreEvent) => void,
@@ -113,9 +126,20 @@ export class HestiaCollection<T extends Record<string, any>> {
     throw new Error("Notify not implemented for dynamic collections");
   }
 
-  page(): PagedData<T> {
+  stream(
+    _options: Record<string, unknown>,
+    _onStreamChange: () => void,
+  ): {
+    stream: () => AsyncIterable<Document<T>>;
+    cancel: () => void;
+    status: () => "active" | "cancelled" | "completed";
+  } {
+    throw new Error("Stream not supported for collections");
+  }
+
+  page(_options?: Record<string, unknown>): PagedData<T> {
     return this.pager;
   }
 }
 
-export type { ServerEnvelope, SingleEnvelope };
+export type { ServerEnvelope, SingleEnvelope };

package/core/errors.ts

@@ -1,4 +1,4 @@
-import {
+import type {
   ApiResponse,
 } from "@asaidimu/network-client"
 import { SystemError, Errors, type Issue } from "@asaidimu/utils-error"

package/core/pager.ts

@@ -1,8 +1,11 @@
 import type { QueryDSL, QueryFilter, SortConfiguration } from "@asaidimu/query";
 import { DELETE_SYMBOL, type DataStore } from "@asaidimu/utils-store";
 import type { Page, PagedData, PagerRefreshOptions } from "./types";
+export type { PagerRefreshOptions }
 import { Debouncer } from "@asaidimu/utils-sync";
 
+declare function requestIdleCallback(cb: (deadline: { didTimeout: boolean }) => void): void;
+
 export interface PageOptions<T extends Record<string, any>> {
   page?: number;
   size?: number;

package/core/types.ts

@@ -1,4 +1,4 @@
-import { QueryFilter, SortConfiguration } from "@asaidimu/query";
+import type { QueryFilter, SortConfiguration } from "@asaidimu/query";
 
 // Internal metadata managed by Anansi
 interface DocumentMetadata {
@@ -275,5 +275,5 @@ export interface DocumentStore<
    * // Navigate
    * await todosPaged.navigate(2);
    */
-  page(options: TPageOptions): Promise<PagedData<T>>;
+  page(options: TPageOptions): PagedData<T>;
 }

package/index.ts

@@ -1,60 +1,37 @@
 // Core
-export { HestiaNetworkClient, HestiaResponse } from "./core/client"
-export type { IdentityProvider  } from "./core/client"
+export * from "./core/client"
 export { HestiaCollection } from "./core/collection"
-export { toSystemError } from "./core/errors"
-
-// Generic types
-export type { Document, Page, PagedData, PaginationInfo, StoreEvent } from "./core/types"
-
-export type { PageOptions } from "./core/pager"
+export * from "./core/errors"
+export * from "./core/types"
+export { createPagedController } from "./core/pager"
 
 // Auth
-export { HestiaAuth } from "./auth/store"
-export type { TokenPair, LoginResult, ServerHealth, LoginRequest, RegisterRequest } from "./auth/types"
+export * from "./auth/store"
+export * from "./auth/types"
 
 // System: identity
-export { HestiaUsers } from "./system/identity/store"
-export type {
-  UserData,
-  UserIdentity,
-  CreateUserRequest,
-  UpdateUserRequest,
-} from "./system/identity/types"
+export * from "./system/identity/store"
+export * from "./system/identity/types"
 
 // System: api-keys
-export { HestiaKeyStore } from "./system/api-keys/store"
-export type { APIKey, APIKeyWithSecret, CreateKeyRequest, UpdateKeyRequest } from "./system/api-keys/types"
+export * from "./system/api-keys/store"
+export * from "./system/api-keys/types"
 
 // System: policies
-export { HestiaPolicies } from "./system/policies/store"
-export type {
-  PolicyOperation,
-  PolicyRule,
-  UpsertOperationRequest,
-  UpsertRuleRequest,
-  ValidateRuleRequest,
-  ValidateRuleResult,
-  ReloadResult,
-} from "./system/policies/types"
+export * from "./system/policies/store"
+export * from "./system/policies/types"
 
 // System: logs
-export { HestiaLogs } from "./system/logs/store"
-export type { AuditEntry, LogFilter } from "./system/logs/types"
+export * from "./system/logs/store"
+export * from "./system/logs/types"
 
 // Blobs
-export { HestiaBlobClient, BlobNamespace } from "./blobs/store"
-export type {
-  NamespaceInfo,
-  BlobMeta,
-  BlobDocument as BlobDoc,
-  ListBlobsRequest,
-  CreateNamespaceRequest,
-} from "./blobs/types"
+export * from "./blobs/store"
+export * from "./blobs/types"
 
 // Collections
-export { HestiaCollections } from "./collections/store"
-export type { CollectionMeta } from "./collections/types"
+export * from "./collections/store"
+export * from "./collections/types"
 
 // Container
 export { HestiaClient } from "./container"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@asaidimu/hestia",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "description": "TypeScript client SDK for the Hestia platform — auth, collections, API keys, policies, audit logs, blobs, and capabilities",
   "type": "module",
   "module": "index.ts",
@@ -21,12 +21,13 @@
     "type": "git",
     "url": "git+https://github.com/asaidimu/hestia.git"
   },
+  "author": "Saidimu <47994458+asaidimu@users.noreply.github.com>",
   "license": "MIT",
-  "author": "Asaidimu <dev@asaidimu.com>",
   "publishConfig": {
     "access": "public"
   },
   "devDependencies": {
+    "@faker-js/faker": "^10.5.0",
     "@types/bun": "latest",
     "vitest": "^4.1.10"
   },
@@ -35,9 +36,12 @@
   },
   "dependencies": {
     "@asaidimu/network-client": "^2.0.0",
+    "@asaidimu/query": "^1.0.0",
     "@asaidimu/utils-artifacts": "^8.2.25",
     "@asaidimu/utils-error": "^1.1.10",
+    "@asaidimu/utils-schema": "^1.0.10",
     "@asaidimu/utils-store": "^10.2.18",
+    "@asaidimu/utils-sync": "^2.3.0",
     "uuid": "^14.0.1"
   }
 }

package/system/api-keys/store.ts

@@ -1,10 +1,22 @@
 import type { QueryDSL } from "@asaidimu/query"
 import { HestiaNetworkClient } from "../../core/client"
-import type { Document, Page, PagedData } from "../../core/types"
+import { ReactiveDataStore } from "@asaidimu/utils-store"
+import { createPagedController } from "../../core/pager"
+import type { Document, Page, PagedData, StoreEvent } from "../../core/types"
+import type { DocumentStore } from "../../core/types"
 import type { APIKey, APIKeyWithSecret, CreateKeyRequest, UpdateKeyRequest } from "./types"
 
-export class HestiaKeyStore {
-  constructor(private client: HestiaNetworkClient) {}
+export class HestiaKeyStore implements DocumentStore<APIKey, QueryDSL<APIKey>, string, QueryDSL<APIKey>, Record<string, unknown>, string, string, Record<string, unknown>> {
+  private pager: PagedData<APIKey>
+
+  constructor(private client: HestiaNetworkClient) {
+    this.pager = createPagedController<APIKey>(
+      "_api_key_",
+      new ReactiveDataStore<any>({}),
+      {},
+      (query) => this.find(query),
+    )
+  }
 
   private basePath = "/system/apikeys/key"
 
@@ -24,8 +36,8 @@ export class HestiaKeyStore {
     return { data: items, loading: false, page: pageMeta }
   }
 
-  async list(): Promise<Page<APIKey>> {
-    return this.find()
+  async list(options?: QueryDSL<APIKey>): Promise<Page<APIKey>> {
+    return options ? this.find(options) : this.find()
   }
 
   async read(id: string): Promise<Document<APIKey> | undefined> {
@@ -41,18 +53,19 @@ export class HestiaKeyStore {
     }
   }
 
-  async create(data: CreateKeyRequest): Promise<Document<APIKeyWithSecret>> {
+  async create(props: { data: Partial<APIKey> }): Promise<Document<APIKey> | undefined> {
     const res = await this.client.post<{ data: Document<APIKeyWithSecret> }>(
       this.basePath,
-      data,
+      props.data as CreateKeyRequest,
     )
     return res.data!.data
   }
 
-  async update(id: string, data: UpdateKeyRequest): Promise<Document<APIKey>> {
+  async update(props: { data: Partial<APIKey>; options?: string }): Promise<Document<APIKey> | undefined> {
+    const id = props.options!
     const res = await this.client.patch<{ data: Document<APIKey> }>(
       `${this.basePath}/${encodeURIComponent(id)}`,
-      data as any,
+      props.data as UpdateKeyRequest,
     )
     return res.data!.data
   }
@@ -61,10 +74,34 @@ export class HestiaKeyStore {
     await this.client.delete(`${this.basePath}/${encodeURIComponent(id)}`)
   }
 
+  async upload(_props: { file: File }): Promise<Document<APIKey> | undefined> {
+    throw new Error("Upload not supported for API keys")
+  }
+
+  async subscribe(_scope: string, _callback: (event: StoreEvent) => void): Promise<() => void> {
+    throw new Error("Subscription not supported for API keys")
+  }
+
+  async notify(_event: StoreEvent): Promise<void> {
+    throw new Error("Notify not supported for API keys")
+  }
+
+  stream(_options: Record<string, unknown>, _onStreamChange: () => void): {
+    stream: () => AsyncIterable<Document<APIKey>>;
+    cancel: () => void;
+    status: () => "active" | "cancelled" | "completed";
+  } {
+    throw new Error("Stream not supported for API keys")
+  }
+
+  page(_options?: Record<string, unknown>): PagedData<APIKey> {
+    return this.pager
+  }
+
   async rotate(id: string): Promise<Document<APIKeyWithSecret>> {
     const res = await this.client.post<{ data: Document<APIKeyWithSecret> }>(
       `${this.basePath}/${encodeURIComponent(id)}`,
     )
     return res.data!.data
   }
-}
+}

package/system/api-keys/types.ts

@@ -2,10 +2,12 @@ export interface APIKey {
   _id_: string
   name: string
   prefix: string
-  scopes: string[]
+  operations: string[]
   status: string
   expiry?: string | null
   environment?: string
+  usage?: number
+  last_used?: string | null
   _metadata_: Record<string, unknown>
 }
 
@@ -16,14 +18,14 @@ export interface APIKeyWithSecret extends APIKey {
 export interface CreateKeyRequest {
   name: string
   environment?: string
-  scopes?: string[]
+  operations?: string[]
   expiry?: string
 }
 
 export interface UpdateKeyRequest {
   name?: string
   environment?: string
-  scopes?: string[]
+  operations?: string[]
   status?: "active" | "revoked"
   expiry?: string
 }

package/system/capabilities/store.ts

@@ -1,23 +1,67 @@
 import { HestiaNetworkClient } from "../../core/client";
-import type { Document } from "../../core/types";
+import type { Document, Page, PagedData, StoreEvent } from "../../core/types";
+import type { DocumentStore } from "../../core/types";
 
-export class HestiaCapabilities {
+export class HestiaCapabilities implements DocumentStore<any, Record<string, unknown>, string, Record<string, unknown>, Record<string, unknown>, string, string, Record<string, unknown>> {
   constructor(
     private client: HestiaNetworkClient,
   ) {
 
   }
 
-  async fetch(): Promise<Array<Document<any>> | undefined> {
-    try {
-      const res = await this.client.get<{ data: Array<Document<any>> }>(
-        `/system/core/docs`,
-      );
-      return res.data?.data;
-    } catch (err: any) {
-      if (err?.code === "SYNC-001-NF") return undefined;
-      throw err;
-    }
+  async find(_query?: Record<string, unknown>): Promise<Page<any>> {
+    const res = await this.client.get<{ data: Array<Document<any>> }>(
+      `/system/core/docs`,
+    );
+    const items = res.data?.data ?? [];
+    return {
+      data: items,
+      loading: false,
+      page: { number: 1, size: items.length, count: items.length, total: items.length, pages: 1 },
+    };
   }
 
-}
+  async read(_id: string): Promise<Document<any> | undefined> {
+    throw new Error("Read by ID not supported for capabilities; use find()")
+  }
+
+  async create(_props: { data: Partial<any> }): Promise<Document<any> | undefined> {
+    throw new Error("Capabilities are read-only")
+  }
+
+  async update(_props: { data: Partial<any>; options?: string }): Promise<Document<any> | undefined> {
+    throw new Error("Capabilities are read-only")
+  }
+
+  async delete(_id: string): Promise<void> {
+    throw new Error("Capabilities are read-only")
+  }
+
+  async list(_options?: Record<string, unknown>): Promise<Page<any>> {
+    return this.find()
+  }
+
+  async upload(_props: { file: File }): Promise<Document<any> | undefined> {
+    throw new Error("Upload not supported for capabilities")
+  }
+
+  async subscribe(_scope: string, _callback: (event: StoreEvent) => void): Promise<() => void> {
+    throw new Error("Subscription not supported for capabilities")
+  }
+
+  async notify(_event: StoreEvent): Promise<void> {
+    throw new Error("Notify not supported for capabilities")
+  }
+
+  stream(_options: Record<string, unknown>, _onStreamChange: () => void): {
+    stream: () => AsyncIterable<Document<any>>;
+    cancel: () => void;
+    status: () => "active" | "cancelled" | "completed";
+  } {
+    throw new Error("Stream not supported for capabilities")
+  }
+
+  page(_options?: Record<string, unknown>): PagedData<any> {
+    throw new Error("Pagination not supported for capabilities")
+  }
+}

package/system/identity/store.ts

@@ -2,10 +2,11 @@ import type { QueryDSL } from "@asaidimu/query";
 import { ReactiveDataStore } from "@asaidimu/utils-store";
 import { HestiaNetworkClient } from "../../core/client";
 import { createPagedController } from "../../core/pager";
-import type { Document, Page, PagedData } from "../../core/types";
+import type { Document, Page, PagedData, StoreEvent } from "../../core/types";
+import type { DocumentStore } from "../../core/types";
 import type { UpdateUserRequest, UserData } from "./types";
 
-export class HestiaUsers {
+export class HestiaUsers implements DocumentStore<UserData, QueryDSL<UserData>, string, QueryDSL<UserData>, Record<string, unknown>, string, string, Record<string, unknown>> {
   private pagerOptions: any = {};
   private pager: PagedData<UserData>;
 
@@ -58,13 +59,11 @@ export class HestiaUsers {
     }
   }
 
-  async update(
-    id: string,
-    data: UpdateUserRequest,
-  ): Promise<Document<UserData>> {
+  async update(props: { data: Partial<UserData>; options?: string }): Promise<Document<UserData> | undefined> {
+    const id = props.options!;
     const res = await this.client.patch<{ data: Document<UserData> }>(
       `/system/users/user/${encodeURIComponent(id)}`,
-      data as any,
+      props.data as any,
     );
     return res.data!.data;
   }
@@ -73,6 +72,34 @@ export class HestiaUsers {
     await this.client.delete(`/system/users/user/${encodeURIComponent(id)}`);
   }
 
+  async create(props: { data: Partial<UserData> }): Promise<Document<UserData> | undefined> {
+    throw new Error("User creation requires email/password/name, use register endpoint");
+  }
+
+  async upload(_props: { file: File }): Promise<Document<UserData> | undefined> {
+    throw new Error("Upload not supported for users");
+  }
+
+  async subscribe(_scope: string, _callback: (event: StoreEvent) => void): Promise<() => void> {
+    throw new Error("Subscription not supported for users");
+  }
+
+  async notify(_event: StoreEvent): Promise<void> {
+    throw new Error("Notify not supported for users");
+  }
+
+  stream(_options: Record<string, unknown>, _onStreamChange: () => void): {
+    stream: () => AsyncIterable<Document<UserData>>;
+    cancel: () => void;
+    status: () => "active" | "cancelled" | "completed";
+  } {
+    throw new Error("Stream not supported for users");
+  }
+
+  page(_options?: Record<string, unknown>): PagedData<UserData> {
+    return this.pager;
+  }
+
   async changePassword(
     userId: string,
     current: string,
@@ -83,8 +110,4 @@ export class HestiaUsers {
       new: newPassword,
     });
   }
-
-  page(): PagedData<UserData> {
-    return this.pager;
-  }
-}
+}

package/system/identity/types.ts

@@ -1,11 +1,11 @@
-import { Document } from "../../core/types"
+import type { Document } from "../../core/types"
 
 export interface UserData {
   email: string
   name: string
   verified: boolean
-  scopes: string[]
-  deleted_at?: string | null
+  permissions: string[]
+  deleted?: string | null
 }
 
 export type UserIdentity = Document<UserData>
@@ -14,14 +14,14 @@ export interface CreateUserRequest {
   email: string
   password: string
   name: string
-  scopes?: string[]
+  permissions?: string[]
   verified?: boolean
 }
 
 export interface UpdateUserRequest {
   name?: string
   email?: string
-  scopes?: string[]
+  permissions?: string[]
   verified?: boolean
 }