@asaidimu/hestia 1.0.1 → 1.0.3

package/system/identity/store.ts

@@ -1,113 +0,0 @@
-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, StoreEvent } from "../../core/types";
-import type { DocumentStore } from "../../core/types";
-import type { UpdateUserRequest, UserData } from "./types";
-
-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>;
-
-  constructor(
-    private client: HestiaNetworkClient,
-  ) {
-    this.pager = createPagedController<UserData>(
-      "users",
-      new ReactiveDataStore<any>({}),
-      this.pagerOptions,
-      (query) => this.find(query),
-    );
-  }
-
-  name() {
-    return "users";
-  }
-
-  async find(query?: QueryDSL<UserData>): Promise<Page<UserData>> {
-    const res = await this.client.post<{
-      data:  Document<UserData>[];
-      metadata?: { page?: any };
-    }>("/system/users/user/query", query ?? {});
-    const data = res.data?.data ?? [];
-    const pageMeta = res.data?.metadata?.page ?? {
-      number: 1,
-      size: data.length,
-      count: data.length,
-      total: data.length,
-      pages: 1,
-    };
-    return { data, loading: false, page: pageMeta };
-  }
-
-  async list(options?: QueryDSL<UserData>): Promise<Page<UserData>> {
-    return this.find(
-      options ?? { pagination: { type: "offset", offset: 0, limit: 50 } },
-    );
-  }
-
-  async read(id: string): Promise<Document<UserData> | undefined> {
-    try {
-      const res = await this.client.get<{ data: Document<UserData> }>(
-        `/system/users/user/${encodeURIComponent(id)}`,
-      );
-      return res.data?.data;
-    } catch (err: any) {
-      if (err?.code === "SYNC-001-NF") return undefined;
-      throw err;
-    }
-  }
-
-  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)}`,
-      props.data as any,
-    );
-    return res.data!.data;
-  }
-
-  async delete(id: string): Promise<void> {
-    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,
-    newPassword: string,
-  ): Promise<void> {
-    await this.client.patch(`/system/users/password/${encodeURIComponent(userId)}`, {
-      current,
-      new: newPassword,
-    });
-  }
-}

package/system/identity/types.ts

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

package/system/policies/store.ts

@@ -1,177 +0,0 @@
-import type { QueryDSL } from "@asaidimu/query"
-import { HestiaNetworkClient } from "../../core/client"
-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 {
-    OperationPolicy,
-    IamRule,
-    UpsertOperationRequest,
-    UpsertRuleRequest,
-    ReloadResult,
-} from "./types"
-
-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.pager = createPagedController<OperationPolicy>(
-      "policies",
-      new ReactiveDataStore<any>({}),
-      {},
-      (query) => this.find(query),
-    )
-  }
-
-  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 find(query?: QueryDSL<OperationPolicy>): Promise<Page<OperationPolicy>> {
-    return this.collectionQuery<OperationPolicy>(OPERATIONS_COLLECTION, query as Record<string, unknown> | undefined)
-  }
-
-  async list(options?: QueryDSL<OperationPolicy>): Promise<Page<OperationPolicy>> {
-    return this.find(options ?? { pagination: { type: "offset", offset: 0, limit: 50 } })
-  }
-
-  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 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 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 delete(id: string): Promise<void> {
-    await this.client.delete(`${this.operationsPath}/${encodeURIComponent(id)}`)
-  }
-
-  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 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 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 deleteRule(name: string): Promise<void> {
-    await this.client.delete(`${this.rulesPath}/${encodeURIComponent(name)}`)
-  }
-
-  async listRules(options?: Record<string, unknown>): Promise<Page<IamRule>> {
-    return this.collectionQuery<IamRule>(RULES_COLLECTION, options)
-  }
-
-  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 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,43 +0,0 @@
-export interface OperationPolicy {
-  name: string
-  ruleKey: string
-  description?: string
-  intentType?: "COMMAND" | "QUERY"
-}
-
-export interface UpsertOperationRequest {
-  ruleKey: string
-  description?: string
-  intentType?: "COMMAND" | "QUERY"
-}
-
-export interface IamRule {
-  name: string
-  ruleType?: string
-  expression?: string
-  description?: string
-}
-
-export interface UpsertRuleRequest {
-  expression: string
-  ruleType?: string
-  description?: string
-}
-
-export interface ValidateRuleRequest {
-  expression: string
-  identity?: Record<string, unknown>
-  resource?: Record<string, unknown>
-  environment?: Record<string, unknown>
-}
-
-export interface ValidateRuleResult {
-  valid: boolean
-  compile?: string
-  result?: boolean
-}
-
-export interface ReloadResult {
-  operations: number
-  rules: number
-}

package/test-setup.ts

@@ -1,53 +0,0 @@
-import { spawn, type ChildProcess } from "child_process"
-import { resolve } from "path"
-
-const PROJECT_ROOT = resolve(import.meta.dirname, "..")
-const SERVER_BIN = resolve(PROJECT_ROOT, "test-server")
-const START_TIMEOUT = 30000
-
-let serverProc: ChildProcess | null = null
-
-function sleep(ms: number): Promise<void> {
-  return new Promise((r) => setTimeout(r, ms))
-}
-
-export async function setup(): Promise<void> {
-  await new Promise<void>((resolvePromise, reject) => {
-    serverProc = spawn(SERVER_BIN, [], {
-      cwd: PROJECT_ROOT,
-      stdio: ["ignore", "pipe", "pipe"],
-    })
-
-    let started = false
-    const onData = (data: Buffer) => {
-      const text = data.toString().trim()
-      if (!started && /^\d+$/.test(text)) {
-        started = true
-        resolvePromise()
-      }
-    }
-
-    serverProc.stdout!.on("data", onData)
-    serverProc.stderr!.on("data", () => {})
-
-    serverProc.on("error", (err) => {
-      if (!started) reject(err)
-    })
-    serverProc.on("exit", (code) => {
-      if (!started) reject(new Error(`server exited with code ${code} before ready`))
-    })
-
-    setTimeout(() => {
-      if (!started) reject(new Error("server start timeout"))
-    }, START_TIMEOUT)
-  })
-
-  await sleep(1000)
-}
-
-export async function teardown(): Promise<void> {
-  if (serverProc && !serverProc.killed) {
-    serverProc.kill("SIGTERM")
-    serverProc = null
-  }
-}

package/utils/index.ts

@@ -1 +0,0 @@
-export * from "./pager"

package/utils/pager.ts

@@ -1,230 +0,0 @@
-import { createMatcher, createSorter } from '@asaidimu/query'; //
-import type { QueryDSL, QueryFilter, SortConfiguration } from '@asaidimu/query'; //
-import { DELETE_SYMBOL, ReactiveDataStore } from "@asaidimu/utils-store"; //
-import type { Page, PagedData, PagerRefreshOptions } from '../core/types';
-
-export interface FetchResult<T extends Record<string, any>> {
-  data: T[];
-  replace: boolean;
-  scope: 'page' | 'collection';
-  total?: number;
-}
-
-// Extensible parameters object embracing your DataStore infra
-export interface ArrayPagerOptions<T extends Record<string, any>, F = any> {
-  collectionName: string; // Unique identifier used to partition the cache matrix
-  initialData?: T[];
-  page?: number;
-  size?: number;
-  customFunctions?: Record<string, (...args: any[]) => boolean>;
-  fetch?: (
-    query: QueryDSL<T, F>
-  ) => Promise<FetchResult<T>> | FetchResult<T>;
-}
-
-export function createArrayPager<T extends Record<string, any>, F = any>(
-  options: ArrayPagerOptions<T, F>
-): PagedData<T> {
-  const CACHE_KEY = `${options.collectionName}_array_pager_state_`; //
-  const store = new ReactiveDataStore({})
-
-  // Baseline backing arrays managed by this adapter instance
-  let pristineData = [...(options.initialData ?? [])];
-  let activeScope: 'page' | 'collection' = 'collection';
-  let remoteTotalRecords: number | undefined = undefined;
-
-  // Track active filter parameters
-  let currentPageNum = options.page ?? 1;
-  let currentPageSize = options.size ?? 20; // Defaulting to 20 per your page controller sentinel
-  let currentSort: SortConfiguration<T>[] = [];
-  let currentFilter: QueryFilter<T> | undefined = undefined;
-
-  // Tracker for errors across async horizons
-  let operationalError: any = undefined;
-
-  const { match } = createMatcher<T, F>(options.customFunctions ?? {}); //
-  const { sort: localSort} = createSorter()
-  const selector = store.select((s: any) => s[CACHE_KEY]); //
-
-  // Default fallback layout conforming strictly to Page<T>
-  const sentinel: Page<T> = { //
-    data: [], //
-    loading: true, //
-    error: undefined,
-    page: { //
-      number: 1, //
-      size: currentPageSize, //
-      count: 0, //
-      total: 0, //
-      pages: 1, //
-    },
-  };
-
-  /**
-   * Constructs the current active QueryDSL footprint.
-   */
-  const buildQueryDSL = (): QueryDSL<T, F> => ({ //
-    filters: currentFilter, //
-    sort: currentSort, //
-    pagination: { //
-      type: 'offset', //
-      offset: (currentPageNum - 1) * currentPageSize, //
-      limit: currentPageSize //
-    }
-  });
-
-  /**
-   * Orchestrates the fetching lifecycle and syncs results into the centralized store.
-   */
-  const executeDataPipeline = async (isLoadingFallback = true) => {
-    if (options.fetch) {
-      operationalError = undefined;
-
-      if (isLoadingFallback) {
-        // Broadcast transitional loading state via the central store
-        const previousState = selector.get() ?? sentinel;
-        await store.set({
-          [CACHE_KEY]: { ...previousState, loading: true, error: undefined }
-        });
-      }
-
-      try {
-        const queryDSL = buildQueryDSL();
-        const result = await options.fetch(queryDSL);
-
-        activeScope = result.scope;
-        remoteTotalRecords = result.total;
-
-        pristineData = result.replace
-          ? [...result.data]
-          : [...pristineData, ...result.data];
-      } catch (error) {
-        operationalError = error;
-      }
-    }
-
-    // Process and dispatch to store
-    const updatedPagePayload = computeProcessedPage(options.fetch ? isLoadingFallback : false);
-    await store.set({ [CACHE_KEY]: updatedPagePayload }); //
-  };
-
-  /**
-   * Coordinates local filtering, sorting and slicing transformations
-   * based on the active structural scope strategy.
-   */
-  const computeProcessedPage = (isLoadingFlag: boolean): Page<T> => { //
-    let records = [...pristineData];
-
-    if (activeScope === 'collection') {
-      // Execute standard local processing passes over the full source collection
-      if (currentFilter) {
-        records = records.filter((item) => match(item, currentFilter!)); //
-      }
-      if (currentSort.length > 0) {
-        records = localSort(records, currentSort); //
-      }
-
-      const total = records.length;
-      const pages = Math.ceil(total / currentPageSize) || 1;
-
-      if (currentPageNum > pages) currentPageNum = pages;
-      if (currentPageNum < 1) currentPageNum = 1;
-
-      const startIdx = (currentPageNum - 1) * currentPageSize;
-      const slicedData = records.slice(startIdx, startIdx + currentPageSize);
-
-      return {
-        data: slicedData as any,
-        loading: isLoadingFlag,
-        error: operationalError,
-        page: { //
-          number: currentPageNum,
-          size: currentPageSize,
-          count: slicedData.length,
-          total,
-          pages,
-        }
-      };
-    }
-
-    // Server-Driven mode: Data array has already been shaped for this target viewport
-    const total = remoteTotalRecords ?? records.length;
-    const pages = Math.ceil(total / currentPageSize) || 1;
-
-    return {
-      data: records as any,
-      loading: isLoadingFlag,
-      error: operationalError,
-      page: { //
-        number: currentPageNum,
-        size: currentPageSize,
-        count: records.length,
-        total,
-        pages,
-      }
-    };
-  };
-
-  // Kickstart immediate bootstrapping pass
-  executeDataPipeline(true);
-
-  return {
-    id: () => CACHE_KEY,
-    page: () => selector.get() ?? sentinel, //
-
-    navigate: async (page: number) => {
-      if (page < 1) throw new Error("Page number must be >= 1"); //
-      currentPageNum = page;
-      await executeDataPipeline(true);
-    },
-
-    resize: async (size: number, page: number) => {
-      if (size < 1) throw new Error("Page size must be >= 1"); //
-      currentPageSize = size;
-      currentPageNum = page;
-      await executeDataPipeline(true);
-    },
-
-    sort: async (sortConfig) => {
-      currentSort = Array.isArray(sortConfig) ? sortConfig : [sortConfig];
-      currentPageNum = 1; // Reset window index
-      await executeDataPipeline(true);
-    },
-
-    filter: async (queryFilter) => {
-      currentFilter = queryFilter;
-      currentPageNum = 1; // Reset window index
-      await executeDataPipeline(true);
-    },
-
-    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 avoid flashing double mutations
-      ]);
-
-      const finishedState = selector.get() ?? sentinel;
-      await store.set({
-        [CACHE_KEY]: { ...finishedState, loading: false } //
-      });
-    },
-
-    subscribe: (listener) => {
-      return selector.subscribe((state) => { //
-        listener(state); //
-      });
-    },
-
-    invalidate: async () => {
-      await store.set({ [CACHE_KEY]: DELETE_SYMBOL }); //
-      pristineData = [];
-    },
-  };
-}

package/vitest.config.ts

@@ -1,8 +0,0 @@
-import { defineConfig } from "vitest/config"
-
-export default defineConfig({
-  test: {
-    globalSetup: ["./test-setup.ts"],
-    fileParallelism: false,
-  },
-})