@withstudiocms/sdk 0.0.0-beta.0 → 0.1.0-beta.1

package/dist/modules/util/collectors.d.ts

@@ -0,0 +1,261 @@
+import { Effect, type ParseResult } from '@withstudiocms/effect';
+import { type DBCallbackFailure } from '@withstudiocms/kysely';
+import type { DatabaseError } from '@withstudiocms/kysely/core/errors';
+import { DBClientLive } from '../../context.js';
+import type { CombinedPageData, CombinedUserData, FolderNode, MetaOnlyPageData, tsPageDataSelect } from '../../types.js';
+import { type FolderTreeError } from './folderTree.js';
+declare const CollectorError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => import("effect/Cause").YieldableError & {
+    readonly _tag: "CollectorError";
+} & Readonly<A>;
+/**
+ * Error class for collector errors.
+ */
+export declare class CollectorError extends CollectorError_base<{
+    cause: unknown;
+}> {
+}
+/**
+ * Utility function to handle errors in collector functions.
+ *
+ * @param _try - The function to execute that may throw an error.
+ * @returns An effect that either yields the result of the function or a CollectorError.
+ */
+export declare const useCollectorError: <T>(_try: () => T) => Effect.Effect<T, CollectorError, never>;
+/**
+ * SDKCollectors
+ *
+ * Effect generator that wires together database access, folder-tree utilities, and parsing helpers
+ * to produce a set of high-level "collector" utilities for assembling richer SDK models from
+ * raw database rows.
+ *
+ * Behavior
+ * - Instantiates required dependencies (DB client, folder-tree helpers, parsers) by yielding the
+ *   corresponding live implementations.
+ * - Exposes a small collection of helper effects and functions that perform typed queries,
+ *   transform results, and compose several queries into complete domain objects.
+ *
+ * Internal helpers (provided inside the effect)
+ * - _getUserData(id: string): Effect that queries StudioCMSUsersTable and decodes the result.
+ * - _getPageContent(id: string): Effect that queries StudioCMSPageContent for multi-language page
+ *   content and decodes the result.
+ * - _getOAuthAccountData(id: string): Effect that queries StudioCMSOAuthAccounts for a user's
+ *   OAuth accounts and decodes the result.
+ * - _getUserPermissionsData(id: string): Effect that queries StudioCMSPermissions for a user's
+ *   permissions and decodes the result.
+ *
+ * Utility functions
+ * - _transformPageDataToMetaOnly:
+ *     Transforms a CombinedPageData (or array thereof) into its metadata-only representation by
+ *     stripping large content fields (defaultContent, multiLangContent). Returns an Effect that
+ *     fails with a CollectorError when transformation fails.
+ * - _collectContributorData(ids: readonly string[]):
+ *     Concurrently fetches user records for a list of contributor IDs and filters out missing
+ *     results.
+ *
+ * Main collectors (returned object)
+ * - collectCategories(ids: number[]):
+ *     Uses a codec-backed query to fetch category rows by id.
+ * - collectTags(ids: number[]):
+ *     Uses a codec-backed query to fetch tag rows by id.
+ * - collectPageData(page, tree, metaOnly = false):
+ *     Assembles a complete page model by concurrently collecting:
+ *       - categories and tags (via parsers -> collectCategories/collectTags),
+ *       - contributor user data,
+ *       - author user data,
+ *       - multi-language page content (when metaOnly is false).
+ *     It computes a safe slug (special-casing "index" -> "/") and resolves the full URL
+ *     route by walking the provided folder tree (using findNodesAlongPathToId) when a
+ *     parentFolder is present.
+ *     Overloads:
+ *       - Without metaOnly (or metaOnly === false) returns CombinedPageData.
+ *       - With metaOnly === true returns MetaOnlyPageData (content stripped via
+ *         _transformPageDataToMetaOnly).
+ *     Possible failure modes include DatabaseError, ParseResult.ParseError, FolderTreeError,
+ *     and CollectorError.
+ * - collectUserData(user):
+ *     Enriches a user row with its OAuth accounts and permissions and returns a CombinedUserData
+ *     result.
+ *
+ * Errors
+ * - All operations are represented as Effects and may fail with the module's domain errors such
+ *   as DatabaseError, ParseResult.ParseError, FolderTreeError, and CollectorError.
+ *
+ * Usage
+ * - The effect yields an object with the above collector functions which can be used by other
+ *   SDK modules to obtain normalized, assembled data for pages, users, tags, and categories.
+ */
+export declare const SDKCollectors: Effect.Effect<{
+    collectCategories: (input: {
+        readonly [x: number]: number;
+        readonly length: number;
+        toString: {};
+        toLocaleString: {};
+        concat: {};
+        join: {};
+        slice: {};
+        indexOf: {};
+        lastIndexOf: {};
+        every: {};
+        some: {};
+        forEach: {};
+        map: {};
+        filter: {};
+        reduce: {};
+        reduceRight: {};
+        find: {};
+        findIndex: {};
+        entries: {};
+        keys: {};
+        values: {};
+        includes: {};
+        flatMap: {};
+        flat: {};
+        at: {};
+        findLast: {};
+        findLastIndex: {};
+        toReversed: {};
+        toSorted: {};
+        toSpliced: {};
+        with: {};
+        [Symbol.iterator]: {};
+        readonly [Symbol.unscopables]: {
+            readonly [x: number]: boolean | undefined;
+            readonly length?: boolean | undefined;
+            toString?: boolean | undefined;
+            toLocaleString?: boolean | undefined;
+            concat?: boolean | undefined;
+            join?: boolean | undefined;
+            slice?: boolean | undefined;
+            indexOf?: boolean | undefined;
+            lastIndexOf?: boolean | undefined;
+            every?: boolean | undefined;
+            some?: boolean | undefined;
+            forEach?: boolean | undefined;
+            map?: boolean | undefined;
+            filter?: boolean | undefined;
+            reduce?: boolean | undefined;
+            reduceRight?: boolean | undefined;
+            find?: boolean | undefined;
+            findIndex?: boolean | undefined;
+            entries?: boolean | undefined;
+            keys?: boolean | undefined;
+            values?: boolean | undefined;
+            includes?: boolean | undefined;
+            flatMap?: boolean | undefined;
+            flat?: boolean | undefined;
+            at?: boolean | undefined;
+            findLast?: boolean | undefined;
+            findLastIndex?: boolean | undefined;
+            toReversed?: boolean | undefined;
+            toSorted?: boolean | undefined;
+            toSpliced?: boolean | undefined;
+            with?: boolean | undefined;
+            [Symbol.iterator]?: boolean | undefined;
+            readonly [Symbol.unscopables]?: boolean | undefined;
+        };
+    }) => Effect.Effect<readonly {
+        readonly name: string;
+        readonly id: number;
+        readonly parent: number | null | undefined;
+        readonly description: string;
+        readonly slug: string;
+        readonly meta: {
+            readonly [x: string]: unknown;
+        };
+    }[], DBCallbackFailure | DatabaseError, never>;
+    collectTags: (input: {
+        readonly [x: number]: number;
+        readonly length: number;
+        toString: {};
+        toLocaleString: {};
+        concat: {};
+        join: {};
+        slice: {};
+        indexOf: {};
+        lastIndexOf: {};
+        every: {};
+        some: {};
+        forEach: {};
+        map: {};
+        filter: {};
+        reduce: {};
+        reduceRight: {};
+        find: {};
+        findIndex: {};
+        entries: {};
+        keys: {};
+        values: {};
+        includes: {};
+        flatMap: {};
+        flat: {};
+        at: {};
+        findLast: {};
+        findLastIndex: {};
+        toReversed: {};
+        toSorted: {};
+        toSpliced: {};
+        with: {};
+        [Symbol.iterator]: {};
+        readonly [Symbol.unscopables]: {
+            readonly [x: number]: boolean | undefined;
+            readonly length?: boolean | undefined;
+            toString?: boolean | undefined;
+            toLocaleString?: boolean | undefined;
+            concat?: boolean | undefined;
+            join?: boolean | undefined;
+            slice?: boolean | undefined;
+            indexOf?: boolean | undefined;
+            lastIndexOf?: boolean | undefined;
+            every?: boolean | undefined;
+            some?: boolean | undefined;
+            forEach?: boolean | undefined;
+            map?: boolean | undefined;
+            filter?: boolean | undefined;
+            reduce?: boolean | undefined;
+            reduceRight?: boolean | undefined;
+            find?: boolean | undefined;
+            findIndex?: boolean | undefined;
+            entries?: boolean | undefined;
+            keys?: boolean | undefined;
+            values?: boolean | undefined;
+            includes?: boolean | undefined;
+            flatMap?: boolean | undefined;
+            flat?: boolean | undefined;
+            at?: boolean | undefined;
+            findLast?: boolean | undefined;
+            findLastIndex?: boolean | undefined;
+            toReversed?: boolean | undefined;
+            toSorted?: boolean | undefined;
+            toSpliced?: boolean | undefined;
+            with?: boolean | undefined;
+            [Symbol.iterator]?: boolean | undefined;
+            readonly [Symbol.unscopables]?: boolean | undefined;
+        };
+    }) => Effect.Effect<readonly {
+        readonly name: string;
+        readonly id: number;
+        readonly description: string;
+        readonly slug: string;
+        readonly meta: {
+            readonly [x: string]: unknown;
+        };
+    }[], DBCallbackFailure | DatabaseError, never>;
+    collectPageData: {
+        (page: tsPageDataSelect, tree: FolderNode[]): Effect.Effect<CombinedPageData, CollectorError | FolderTreeError | DBCallbackFailure | DatabaseError | ParseResult.ParseError, never>;
+        (page: tsPageDataSelect, tree: FolderNode[], metaOnly: boolean): Effect.Effect<MetaOnlyPageData, CollectorError | FolderTreeError | DBCallbackFailure | DatabaseError | ParseResult.ParseError, never>;
+    };
+    collectUserData: (user: {
+        readonly name: string;
+        readonly id: string;
+        readonly url: string | null | undefined;
+        readonly email: string | null | undefined;
+        readonly avatar: string | null | undefined;
+        readonly username: string;
+        readonly password: string | null | undefined;
+        readonly updatedAt: Date;
+        readonly createdAt: Date;
+        readonly emailVerified: boolean;
+        readonly notifications: string | null | undefined;
+    }) => Effect.Effect<CombinedUserData, DBCallbackFailure | DatabaseError, never>;
+}, never, DBClientLive>;
+export {};

package/dist/modules/util/collectors.js

@@ -0,0 +1,141 @@
+import { Data, Effect, Schema } from "@withstudiocms/effect";
+import {
+  StudioCMSOAuthAccounts,
+  StudioCMSPageContent,
+  StudioCMSPageDataCategories,
+  StudioCMSPageDataTags,
+  StudioCMSPermissions,
+  StudioCMSUsersTable
+} from "@withstudiocms/kysely";
+import { DBClientLive } from "../../context.js";
+import { SDKFolderTree } from "./folderTree.js";
+import { SDKParsers } from "./parsers.js";
+import { slugify } from "./slugify.js";
+class CollectorError extends Data.TaggedError("CollectorError") {
+}
+const useCollectorError = (_try) => Effect.try({
+  try: _try,
+  catch: (error) => new CollectorError({ cause: error })
+});
+const SDKCollectors = Effect.gen(function* () {
+  const [{ withCodec }, { findNodesAlongPathToId }, { parseIdNumberArray, parseIdStringArray }] = yield* Effect.all([DBClientLive, SDKFolderTree, SDKParsers]);
+  const _getUserData = withCodec({
+    encoder: Schema.String,
+    decoder: Schema.UndefinedOr(StudioCMSUsersTable.Select),
+    callbackFn: (query, id) => query(
+      (db) => db.selectFrom("StudioCMSUsersTable").selectAll().where("id", "=", id).executeTakeFirst()
+    )
+  });
+  const _getPageContent = withCodec({
+    encoder: Schema.String,
+    decoder: Schema.Array(StudioCMSPageContent.Select),
+    callbackFn: (query, id) => query(
+      (db) => db.selectFrom("StudioCMSPageContent").selectAll().where("contentId", "=", id).execute()
+    )
+  });
+  const _getOAuthAccountData = withCodec({
+    encoder: Schema.String,
+    decoder: Schema.Array(StudioCMSOAuthAccounts.Select),
+    callbackFn: (query, id) => query(
+      (db) => db.selectFrom("StudioCMSOAuthAccounts").selectAll().where("userId", "=", id).execute()
+    )
+  });
+  const _getUserPermissionsData = withCodec({
+    encoder: Schema.String,
+    decoder: Schema.UndefinedOr(StudioCMSPermissions.Select),
+    callbackFn: (query, id) => query(
+      (db) => db.selectFrom("StudioCMSPermissions").selectAll().where("user", "=", id).executeTakeFirst()
+    )
+  });
+  const _transformPageDataToMetaOnly = (data) => useCollectorError(() => {
+    if (Array.isArray(data)) {
+      return data.map(
+        ({ defaultContent, multiLangContent, ...rest2 }) => rest2
+      );
+    }
+    const {
+      defaultContent: _dump1,
+      multiLangContent: _dump2,
+      ...rest
+    } = data;
+    return rest;
+  });
+  const _collectContributorData = Effect.fn(
+    (ids) => Effect.all(ids.map((id) => _getUserData(id))).pipe(
+      Effect.map((results) => results.filter((user) => !!user))
+    )
+  );
+  const collectCategories = withCodec({
+    encoder: Schema.Array(Schema.Number),
+    decoder: Schema.Array(StudioCMSPageDataCategories.Select),
+    callbackFn: (db, ids) => db(
+      (c) => c.selectFrom("StudioCMSPageDataCategories").selectAll().where("id", "in", ids).execute()
+    )
+  });
+  const collectTags = withCodec({
+    encoder: Schema.Array(Schema.Number),
+    decoder: Schema.Array(StudioCMSPageDataTags.Select),
+    callbackFn: (db, ids) => db((c) => c.selectFrom("StudioCMSPageDataTags").selectAll().where("id", "in", ids).execute())
+  });
+  function collectPageData(page, tree, metaOnly = false) {
+    return Effect.gen(function* () {
+      const [categories, tags, contributorsData, authorData] = yield* Effect.all([
+        parseIdNumberArray(page.categories || []).pipe(Effect.flatMap(collectCategories)),
+        parseIdNumberArray(page.tags || []).pipe(Effect.flatMap(collectTags)),
+        parseIdStringArray(page.contributorIds || []).pipe(Effect.flatMap(_collectContributorData)),
+        _getUserData(page.authorId)
+      ]);
+      let multiLangContent = [];
+      if (!metaOnly) {
+        multiLangContent = yield* _getPageContent(page.id);
+      }
+      const defaultContent = multiLangContent?.find(
+        (content) => content.contentLang === page.contentLang
+      );
+      const safeSlug = page.slug === "index" ? "/" : slugify(page.slug);
+      let urlRoute = safeSlug.startsWith("/") ? safeSlug : `/${safeSlug}`;
+      if (page.parentFolder) {
+        const urlParts = yield* findNodesAlongPathToId(tree, page.parentFolder);
+        const folderPath = urlParts.map(({ name }) => slugify(name)).join("/");
+        urlRoute = folderPath.length > 0 ? `/${folderPath}${safeSlug === "/" ? "" : `/${safeSlug}`}` : safeSlug;
+      }
+      const returnData = {
+        ...page,
+        slug: safeSlug,
+        urlRoute,
+        categories,
+        tags,
+        authorData,
+        contributorsData,
+        multiLangContent,
+        defaultContent
+      };
+      if (metaOnly) {
+        return yield* _transformPageDataToMetaOnly(returnData);
+      }
+      return returnData;
+    });
+  }
+  const collectUserData = Effect.fn(
+    (user) => Effect.all([_getOAuthAccountData(user.id), _getUserPermissionsData(user.id)]).pipe(
+      Effect.map(
+        ([oAuthData, permissionsData]) => ({
+          ...user,
+          oAuthData,
+          permissionsData
+        })
+      )
+    )
+  );
+  return {
+    collectCategories,
+    collectTags,
+    collectPageData,
+    collectUserData
+  };
+});
+export {
+  CollectorError,
+  SDKCollectors,
+  useCollectorError
+};

package/dist/modules/util/folderTree.d.ts

@@ -0,0 +1,100 @@
+import { Effect } from '@withstudiocms/effect';
+import { DBClientLive } from '../../context.js';
+import type { FolderListItem, FolderNode } from '../../types.js';
+declare const FolderTreeError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => import("effect/Cause").YieldableError & {
+    readonly _tag: "FolderTreeError";
+} & Readonly<A>;
+/**
+ * Custom error class for folder tree related errors.
+ */
+export declare class FolderTreeError extends FolderTreeError_base<{
+    cause: unknown;
+}> {
+}
+/**
+ * Utility function to wrap operations with FolderTreeError handling.
+ *
+ * @param _try - A function that performs the operation to be wrapped.
+ * @returns An Effect that either yields the result of the operation or a FolderTreeError.
+ */
+export declare const useFolderTreeError: <T>(_try: () => T) => Effect.Effect<T, FolderTreeError, never>;
+/**
+ * SDKFolderTree
+ *
+ * An Effect.Gen that provides utilities for constructing and querying an in-memory folder tree
+ * representation derived from the StudioCMSPageFolderStructure table.
+ *
+ * This effect:
+ * - Fetches the current folder records from the database using DBClientLive and a typed decoder.
+ * - Exposes pure and effectful helper functions for building a hierarchical tree, searching nodes
+ *   by path or id, and adding page nodes to the tree.
+ *
+ * Exposed functions and behavior:
+ * - generateFolderTree(folders: readonly tsPageFolderSelect[]): FolderNode[]
+ *   Builds a hierarchical FolderNode[] from a flat list of folder records. Each FolderNode
+ *   contains id, name, pageData, page (boolean), and children (FolderNode[]).
+ *
+ * - getFullPath(tree: FolderNode[], path: string[]): string[]
+ *   Returns the sequence of folder names from the root down to the specified path of folder names.
+ *   If the supplied path is not found, returns the longest matched prefix (or an empty array).
+ *
+ * - findNodeByPath(tree: FolderNode[], path: string[]): FolderNode | null
+ *   Locates and returns the FolderNode that exactly matches the supplied path of folder names.
+ *   Returns null if the full path does not exist.
+ *
+ * - findNodesAlongPath(tree: FolderNode[], path: string[]): FolderNode[]
+ *   Returns the array of FolderNode objects encountered along the specified path of names.
+ *   Useful for obtaining each node in the chain (root → ... → target). Returns an empty array
+ *   when no match is found.
+ *
+ * - findNodesAlongPathToId(tree: FolderNode[], id: string): FolderNode[]
+ *   Searches the tree for a node by id and returns all FolderNode objects along the path from
+ *   the root to that node. If the id is not found, an empty array is returned.
+ *
+ * - findNodeById(tree: FolderNode[], id: string): FolderNode | null
+ *   Recursively searches and returns the FolderNode with the matching id, or null when not found.
+ *
+ * - addPageToFolderTree(tree: FolderNode[], folderId: string, newPage: FolderNode): FolderNode[]
+ *   Effectful helper that inserts a new page node under the folder with folderId. If no folder
+ *   with folderId exists, the newPage is appended at the root level. Returns the updated tree.
+ *
+ * - buildFolderTree: Effect<unknown, Error, FolderNode[]>
+ *   Effect that fetches current folders from the DB and maps them to a hierarchical tree using
+ *   generateFolderTree.
+ *
+ * - getAvailableFolders: Effect<unknown, Error, FolderListItem[]>
+ *   Effect that fetches current folders from the DB and returns a light-weight list of folder
+ *   descriptors { id, name, parent } for UI lists or selection controls.
+ *
+ * Notes and guarantees:
+ * - All helpers wrap their logic in a folder-tree specific error boundary via useFolderTreeError,
+ *   so callers receive consistent errors for tree operations.
+ * - The internal representation assumes unique folder ids and uses the parent id to assemble
+ *   the hierarchy; folders with a null/undefined parent are treated as root nodes.
+ * - The effect depends on DBClientLive and a decoder for StudioCMSPageFolderStructure to ensure
+ *   type-safe database reads.
+ *
+ * @remarks
+ * Intended for use by SDK consumers that need to present, navigate, or mutate a folder hierarchy
+ * derived from persistent storage. Consumers should treat returned FolderNode[] as a mutable
+ * structure when using addPageToFolderTree; other helpers are pure and deterministic.
+ *
+ * @returns An Effect that yields an object exposing the functions described above for building
+ *          and querying folder trees.
+ */
+export declare const SDKFolderTree: Effect.Effect<{
+    generateFolderTree: (folders: readonly {
+        readonly name: string;
+        readonly id: string;
+        readonly parent: string | null | undefined;
+    }[]) => Effect.Effect<FolderNode[], FolderTreeError, never>;
+    getFullPath: (tree: FolderNode[], path: string[]) => Effect.Effect<string[], FolderTreeError, never>;
+    findNodeByPath: (tree: FolderNode[], path: string[]) => Effect.Effect<FolderNode | null, FolderTreeError, never>;
+    findNodesAlongPath: (tree: FolderNode[], path: string[]) => Effect.Effect<FolderNode[], FolderTreeError, never>;
+    findNodesAlongPathToId: (tree: FolderNode[], id: string) => Effect.Effect<FolderNode[], FolderTreeError, never>;
+    findNodeById: (tree: FolderNode[], id: string) => Effect.Effect<FolderNode | null, FolderTreeError, never>;
+    addPageToFolderTree: (tree: FolderNode[], folderId: string, newPage: FolderNode) => Effect.Effect<FolderNode[], FolderTreeError, never>;
+    buildFolderTree: Effect.Effect<FolderNode[], import("@withstudiocms/kysely").DBCallbackFailure | import("@withstudiocms/kysely/core/errors").DatabaseError | FolderTreeError, never>;
+    getAvailableFolders: Effect.Effect<FolderListItem[], import("@withstudiocms/kysely").DBCallbackFailure | import("@withstudiocms/kysely/core/errors").DatabaseError, never>;
+}, never, DBClientLive>;
+export {};

package/dist/modules/util/folderTree.js

@@ -0,0 +1,176 @@
+import { Data, Effect, Schema } from "@withstudiocms/effect";
+import { StudioCMSPageFolderStructure } from "@withstudiocms/kysely";
+import { DBClientLive } from "../../context.js";
+class FolderTreeError extends Data.TaggedError("FolderTreeError") {
+}
+const useFolderTreeError = (_try) => Effect.try({
+  try: _try,
+  catch: (error) => new FolderTreeError({ cause: error })
+});
+const SDKFolderTree = Effect.gen(function* () {
+  const { withDecoder } = yield* DBClientLive;
+  const _getCurrentFolders = withDecoder({
+    decoder: Schema.Array(StudioCMSPageFolderStructure.Select),
+    callbackFn: (query) => query((db) => db.selectFrom("StudioCMSPageFolderStructure").selectAll().execute())
+  });
+  const generateFolderTree = Effect.fn(
+    (folders) => useFolderTreeError(() => {
+      const folderMap = {};
+      for (const folder of folders) {
+        folderMap[folder.id] = {
+          id: folder.id,
+          name: folder.name,
+          pageData: null,
+          page: false,
+          children: []
+        };
+      }
+      const rootFolders = [];
+      for (const folder of folders) {
+        const childFolder = folderMap[folder.id];
+        if (!childFolder) continue;
+        if (folder.parent === null || folder.parent === void 0) {
+          rootFolders.push(childFolder);
+        } else {
+          const parentFolder = folderMap[folder.parent];
+          if (parentFolder) {
+            parentFolder.children.push(childFolder);
+          }
+        }
+      }
+      return rootFolders;
+    })
+  );
+  const getFullPath = Effect.fn(
+    (tree, path) => useFolderTreeError(() => {
+      const result = [];
+      function helper(nodes, pathParts) {
+        if (pathParts.length === 0) return false;
+        const [current, ...rest] = pathParts;
+        for (const node of nodes) {
+          if (node.name === current) {
+            result.push(node.name);
+            if (rest.length === 0 || helper(node.children, rest)) {
+              return true;
+            }
+            result.pop();
+          }
+        }
+        return false;
+      }
+      helper(tree, path);
+      return result;
+    })
+  );
+  const findNodeByPath = Effect.fn(
+    (tree, path) => useFolderTreeError(() => {
+      function _findNodeByPath(tree2, path2) {
+        if (path2.length === 0) return null;
+        const [current, ...rest] = path2;
+        for (const node of tree2) {
+          if (node.name === current) {
+            if (rest.length === 0) return node;
+            return _findNodeByPath(node.children, rest);
+          }
+        }
+        return null;
+      }
+      return _findNodeByPath(tree, path);
+    })
+  );
+  const findNodesAlongPath = Effect.fn(
+    (tree, path) => useFolderTreeError(() => {
+      const result = [];
+      function helper(nodes, pathParts) {
+        if (pathParts.length === 0) return false;
+        const [current, ...rest] = pathParts;
+        for (const node of nodes) {
+          if (node.name === current) {
+            result.push(node);
+            if (rest.length === 0 || helper(node.children, rest)) {
+              return true;
+            }
+            result.pop();
+          }
+        }
+        return false;
+      }
+      helper(tree, path);
+      return result;
+    })
+  );
+  const findNodesAlongPathToId = Effect.fn(
+    (tree, id) => useFolderTreeError(() => {
+      const path = [];
+      function helper(nodes, targetId) {
+        for (const node of nodes) {
+          path.push(node);
+          if (node.id === targetId) {
+            return true;
+          }
+          if (helper(node.children, targetId)) {
+            return true;
+          }
+          path.pop();
+        }
+        return false;
+      }
+      helper(tree, id);
+      return path;
+    })
+  );
+  const findNodeById = Effect.fn(
+    (tree, id) => useFolderTreeError(() => {
+      function _findNodeById(tree2, id2) {
+        for (const node of tree2) {
+          if (node.id === id2) {
+            return node;
+          }
+          const found = _findNodeById(node.children, id2);
+          if (found) {
+            return found;
+          }
+        }
+        return null;
+      }
+      return _findNodeById(tree, id);
+    })
+  );
+  const addPageToFolderTree = Effect.fn(function* (tree, folderId, newPage) {
+    const parentFolder = yield* findNodeById(tree, folderId);
+    if (!parentFolder) {
+      tree.push(newPage);
+      return tree;
+    }
+    parentFolder.children.push(newPage);
+    return tree;
+  });
+  const buildFolderTree = _getCurrentFolders().pipe(Effect.flatMap(generateFolderTree));
+  const getAvailableFolders = _getCurrentFolders().pipe(
+    Effect.map(
+      (folders) => folders.map(
+        (folder) => ({
+          id: folder.id,
+          name: folder.name,
+          parent: folder.parent
+        })
+      )
+    )
+  );
+  return {
+    generateFolderTree,
+    getFullPath,
+    findNodeByPath,
+    findNodesAlongPath,
+    findNodesAlongPathToId,
+    findNodeById,
+    addPageToFolderTree,
+    buildFolderTree,
+    getAvailableFolders
+  };
+});
+export {
+  FolderTreeError,
+  SDKFolderTree,
+  useFolderTreeError
+};