@withstudiocms/sdk 0.0.0-beta.0 → 0.1.0

package/dist/modules/rest_api/index.js

@@ -0,0 +1,117 @@
+import { Effect, Schema } from "@withstudiocms/effect";
+import { DBClientLive } from "../../context.js";
+import { StudioCMSAPIKeys, StudioCMSPermissions } from "../../tables.js";
+import { SDKGenerators } from "../util/generators.js";
+const SDKRestAPIModule = Effect.gen(function* () {
+  const [{ withCodec, withEncoder }, { generateToken }] = yield* Effect.all([
+    DBClientLive,
+    SDKGenerators
+  ]);
+  const _getTokensForUser = withCodec({
+    encoder: Schema.String,
+    decoder: Schema.Array(StudioCMSAPIKeys.Select),
+    callbackFn: (db, userId) => db(
+      (client) => client.selectFrom("StudioCMSAPIKeys").selectAll().where("userId", "=", userId).execute()
+    )
+  });
+  const _newToken = withCodec({
+    encoder: StudioCMSAPIKeys.Insert,
+    decoder: StudioCMSAPIKeys.Select,
+    callbackFn: (db, tokenData) => db(
+      (client) => client.transaction().execute(async (trx) => {
+        await trx.insertInto("StudioCMSAPIKeys").values(tokenData).executeTakeFirstOrThrow();
+        return await trx.selectFrom("StudioCMSAPIKeys").selectAll().where("id", "=", tokenData.id).executeTakeFirstOrThrow();
+      })
+    )
+  });
+  const _deleteToken = withEncoder({
+    encoder: Schema.Struct({
+      userId: Schema.String,
+      tokenId: Schema.String
+    }),
+    callbackFn: (db, { userId, tokenId }) => db(
+      (client) => client.deleteFrom("StudioCMSAPIKeys").where("userId", "=", userId).where("id", "=", tokenId).execute()
+    )
+  });
+  const _getByKey = withCodec({
+    encoder: Schema.String,
+    decoder: Schema.UndefinedOr(StudioCMSAPIKeys.Select),
+    callbackFn: (db, key) => db(
+      (client) => client.selectFrom("StudioCMSAPIKeys").selectAll().where("key", "=", key).executeTakeFirst()
+    )
+  });
+  const _getKeyPermissions = withCodec({
+    encoder: Schema.String,
+    decoder: Schema.UndefinedOr(StudioCMSPermissions.Select),
+    callbackFn: (db, userId) => db(
+      (client) => client.selectFrom("StudioCMSPermissions").selectAll().where("user", "=", userId).executeTakeFirst()
+    )
+  });
+  const _createNewTokenForUser = Effect.fn(
+    (userId, description) => generateToken(userId, true).pipe(
+      Effect.flatMap(
+        (key) => _newToken({
+          id: crypto.randomUUID(),
+          key,
+          userId,
+          description,
+          creationDate: (/* @__PURE__ */ new Date()).toISOString()
+        })
+      )
+    )
+  );
+  const _verifyToken = Effect.fn(
+    (key) => Effect.gen(function* () {
+      const apiKeyRecord = yield* _getByKey(key);
+      if (!apiKeyRecord) return false;
+      const permissionsRecord = yield* _getKeyPermissions(apiKeyRecord.userId);
+      if (!permissionsRecord) return false;
+      return {
+        userId: apiKeyRecord.userId,
+        key: apiKeyRecord.key,
+        rank: permissionsRecord.rank
+      };
+    })
+  );
+  const tokens = {
+    /**
+     * Retrieves all API tokens for a specific user.
+     *
+     * @param userId - The ID of the user whose tokens are to be retrieved.
+     * @returns An Effect that resolves to an array of API keys for the user.
+     * @throws {LibSQLDatabaseError} If a database error occurs during the operation.
+     */
+    get: _getTokensForUser,
+    /**
+     * Creates a new API token for a user with the specified description.
+     *
+     * @param userId - The ID of the user for whom to create the token.
+     * @param description - A description for the API key.
+     * @returns An Effect that resolves to the created API key record.
+     * @throws {LibSQLDatabaseError} If a database error occurs during the operation.
+     */
+    new: _createNewTokenForUser,
+    /**
+     * Deletes an API token for a user by its ID.
+     *
+     * @param userId - The ID of the user whose token is to be deleted.
+     * @param tokenId - The ID of the API token to delete.
+     * @returns An Effect that resolves when the token is successfully deleted.
+     * @throws {LibSQLDatabaseError} If a database error occurs during the operation.
+     */
+    delete: _deleteToken,
+    /**
+     * Verifies an API token and retrieves associated user information.
+     *
+     * @param key - The API token to verify.
+     * @returns An Effect that resolves to user information if the token is valid, or false if invalid.
+     */
+    verify: _verifyToken
+  };
+  return { tokens };
+});
+var rest_api_default = SDKRestAPIModule;
+export {
+  SDKRestAPIModule,
+  rest_api_default as default
+};

package/dist/modules/update/index.d.ts

@@ -0,0 +1,184 @@
+import { Effect } from '@withstudiocms/effect';
+import CacheService from '../../cache.js';
+import { DBClientLive } from '../../context.js';
+import { StudioCMSPageContent, StudioCMSPageData } from '../../tables.js';
+/**
+ * CombinedPageUpdateData
+ *
+ * Type representing the combined data required to update both page data and page content.
+ */
+type CombinedPageUpdateData = {
+    pageData: (typeof StudioCMSPageData.Update)['Type'];
+    pageContent: (typeof StudioCMSPageContent.Update)['Type'];
+};
+/**
+ * SDKUpdateModule
+ *
+ * Effect generator that constructs and returns the SDK "UPDATE" module containing all update-related operations
+ * for the StudioCMS domain. Each operation is implemented as an Effect and typically combines:
+ * - a DB update operation (wrapped with a codec for runtime encode/decode/validation),
+ * - optional cache invalidation or cache refresh,
+ * - and retrieval of the fresh resource via the GET module when appropriate.
+ *
+ * @module SDKUpdateModule
+ *
+ * @remarks
+ * - Dependencies resolved by the generator: DBClientLive, CacheService, SDKClearModule, SDKGetModule, SDKConfigModule.
+ * - DB operations are created via withCodec with corresponding encoder/decoder codecs (e.g. StudioCMSPageContent, StudioCMSPageData, StudioCMSPermissions, etc.).
+ * - Cache-related operations include clearing/invalidation of folder tree/list caches, page-specific cache deletion, and npm package cache tag invalidation.
+ * - Composite helpers coordinate multi-step flows, e.g. updating page content + page data + deleting the page cache, then returning the fresh page via GET.
+ * - All operations are effectful and intended to be executed inside the Effect runtime; callers should compose and run them using the Effect primitives provided by the environment.
+ *
+ * @returns {{
+ *   pageContent: Effect, tags: Effect, categories: Effect, permissions: Effect,
+ *   folderTree: Effect, folderList: Effect, folder: Effect,
+ *   latestVersion: Effect, siteConfig: Effect,
+ *   page: { byId: Effect, bySlug: Effect }
+ * }}
+ * An object exposing update operations:
+ * - pageContent, tags, categories, permissions: DB update Effects returning the updated record.
+ * - folderTree, folderList: Effects that refresh corresponding caches.
+ * - folder: updates a folder entry and invalidates/refreshes folder caches.
+ * - latestVersion: invalidates npm package cache tags and fetches the latest package version.
+ * - siteConfig: forwards to CONFIG.siteConfig.update.
+ * - page.byId: updates page data and content, deletes the page cache, refreshes folder caches, then returns the updated page.
+ * - page.bySlug: resolves the page id by slug and delegates to page.byId.
+ *
+ * @example
+ * // Typical usage inside an Effect:
+ * // yield* Effect.flatMap(UPDATE.page.byId('pageId', combinedPageUpdateData))
+ *
+ * @threadSafety
+ * Effects encapsulate async side effects; callers should treat composite updates as atomic logical operations but not assume cross-operation DB transactions unless provided by the DB client.
+ *
+ * @errors
+ * - DB client errors (e.g. executeTakeFirstOrThrow) propagate as Effect failures.
+ * - Codec validation errors are raised if supplied data does not conform to the expected codec schemas.
+ *
+ * @see SDKGetModule for read operations
+ * @see SDKClearModule for explicit cache clearing operations
+ */
+export declare const SDKUpdateModule: Effect.Effect<{
+    /**
+     * Update Page Content
+     *
+     * @param data - The page content data to update.
+     * @returns The updated page content.
+     */
+    pageContent: (input: {
+        readonly id: string;
+        readonly contentLang: string;
+        readonly contentId: string;
+        readonly content: string;
+    }) => Effect.Effect<{
+        readonly id: string;
+        readonly contentLang: string;
+        readonly contentId: string;
+        readonly content: string;
+    }, import("@withstudiocms/kysely/client").DBCallbackFailure | import("@withstudiocms/kysely/core/errors").DatabaseError, never>;
+    /**
+     * Update Tag
+     *
+     * @param data - The tag data to update.
+     * @returns The updated tag.
+     */
+    tags: (input: {
+        readonly id: number;
+        readonly name: string;
+        readonly description: string;
+        readonly slug: string;
+        readonly meta: string;
+    }) => Effect.Effect<{
+        readonly id: number;
+        readonly name: string;
+        readonly description: string;
+        readonly slug: string;
+        readonly meta: {
+            readonly [x: string]: unknown;
+        };
+    }, import("@withstudiocms/kysely/client").DBCallbackFailure | import("@withstudiocms/kysely/core/errors").DatabaseError, never>;
+    /**
+     * Update Category
+     *
+     * @param data - The category data to update.
+     * @returns The updated category.
+     */
+    categories: (input: {
+        readonly id: number;
+        readonly name: string;
+        readonly description: string;
+        readonly parent?: number | null | undefined;
+        readonly slug: string;
+        readonly meta: string;
+    }) => Effect.Effect<{
+        readonly id: number;
+        readonly name: string;
+        readonly description: string;
+        readonly parent?: number | null | undefined;
+        readonly slug: string;
+        readonly meta: {
+            readonly [x: string]: unknown;
+        };
+    }, import("@withstudiocms/kysely/client").DBCallbackFailure | import("@withstudiocms/kysely/core/errors").DatabaseError, never>;
+    /**
+     * Update Permissions
+     *
+     * @param data - The permissions data to update.
+     * @returns The updated permissions.
+     */
+    permissions: (input: {
+        readonly user: string;
+        readonly rank: "owner" | "admin" | "editor" | "visitor" | "unknown";
+    }) => Effect.Effect<{
+        readonly user: string;
+        readonly rank: "owner" | "admin" | "editor" | "visitor" | "unknown";
+    }, import("@withstudiocms/kysely/client").DBCallbackFailure | import("@withstudiocms/kysely/core/errors").DatabaseError, never>;
+    /**
+     * Update Folder Tree Cache
+     */
+    folderTree: Effect.Effect<import("../../types.js").FolderNode[], import("@withstudiocms/kysely/client").DBCallbackFailure | import("@withstudiocms/kysely/core/errors").DatabaseError | import("../util/folderTree.js").FolderTreeError, never>;
+    /**
+     * Update Folder List Cache
+     */
+    folderList: Effect.Effect<import("../../types.js").FolderListItem[], import("@withstudiocms/kysely/client").DBCallbackFailure | import("@withstudiocms/kysely/core/errors").DatabaseError, never>;
+    /**
+     * Update Folder Entry and Invalidate Related Caches
+     *
+     * @param data - The folder entry data to update.
+     * @returns The updated folder entry.
+     */
+    folder: (data: {
+        readonly id: string;
+        readonly name: string;
+        readonly parent?: string | null | undefined;
+    }) => Effect.Effect<{
+        readonly id: string;
+        readonly name: string;
+        readonly parent?: string | null | undefined;
+    }, import("@withstudiocms/kysely/client").DBCallbackFailure | import("@withstudiocms/kysely/core/errors").DatabaseError | import("../util/folderTree.js").FolderTreeError, never>;
+    /**
+     * Update Latest NPM Package Version
+     */
+    latestVersion: () => Effect.Effect<{
+        version: string;
+        lastCacheUpdate: Date;
+    }, import("effect/Cause").UnknownException | import("effect/ParseResult").ParseError | import("../util/getFromNPM.js").GetFromNPMError, never>;
+    /**
+     * Update Site Configuration
+     */
+    siteConfig: (data: import("../../types.js").ConfigFinal<import("../../types.js").StudioCMSSiteConfig>) => Effect.Effect<import("../../types.js").DynamicConfigEntry<import("../../types.js").StudioCMSSiteConfig>, import("@withstudiocms/kysely/client").DBCallbackFailure | import("@withstudiocms/kysely/core/errors").DatabaseError, never>;
+    /**
+     * Page Operations
+     */
+    page: {
+        /**
+         * Update Page by ID
+         */
+        byId: (pageId: string, data: CombinedPageUpdateData) => Effect.Effect<import("../../types.js").CombinedPageData | undefined, import("effect/ParseResult").ParseError | import("@withstudiocms/kysely/client").DBCallbackFailure | import("@withstudiocms/kysely/core/errors").QueryParseError | import("@withstudiocms/kysely/core/errors").QueryError | import("@withstudiocms/kysely/core/errors").NotFoundError | import("../util/folderTree.js").FolderTreeError | import("../util/collectors.js").CollectorError | import("../get/index.js").PaginateError, never>;
+        /**
+         * Update Page by Slug
+         */
+        bySlug: (slug: string, data: CombinedPageUpdateData) => Effect.Effect<import("../../types.js").CombinedPageData | undefined, import("effect/ParseResult").ParseError | import("@withstudiocms/kysely/client").DBCallbackFailure | import("@withstudiocms/kysely/core/errors").DatabaseError | import("../util/folderTree.js").FolderTreeError | import("../util/collectors.js").CollectorError | import("../get/index.js").PaginateError, never>;
+    };
+}, never, DBClientLive | import("../../context.js").SDKDefaults | import("../../context.js").StorageManagerResolver | CacheService | import("@withstudiocms/effect").Deepmerge>;
+export default SDKUpdateModule;

package/dist/modules/update/index.js

@@ -0,0 +1,192 @@
+import { Effect, Schema } from "@withstudiocms/effect";
+import CacheService from "../../cache.js";
+import { cacheKeyGetters, cacheTags } from "../../consts.js";
+import { DBClientLive } from "../../context.js";
+import {
+  StudioCMSPageContent,
+  StudioCMSPageData,
+  StudioCMSPageDataCategories,
+  StudioCMSPageDataTags,
+  StudioCMSPageFolderStructure,
+  StudioCMSPermissions
+} from "../../tables.js";
+import SDKClearModule from "../clear/index.js";
+import SDKConfigModule from "../config/index.js";
+import SDKGetModule from "../get/index.js";
+const SDKUpdateModule = Effect.gen(function* () {
+  const [{ withCodec }, CACHE, CLEAR, GET, CONFIG] = yield* Effect.all([
+    DBClientLive,
+    CacheService,
+    SDKClearModule,
+    SDKGetModule,
+    SDKConfigModule
+  ]);
+  const _updatePageContent = withCodec({
+    encoder: StudioCMSPageContent.Update,
+    decoder: StudioCMSPageContent.Select,
+    callbackFn: (db, data) => db(
+      (client) => client.transaction().execute(async (trx) => {
+        await trx.updateTable("StudioCMSPageContent").set(data).where("id", "=", data.id).executeTakeFirstOrThrow();
+        return await trx.selectFrom("StudioCMSPageContent").selectAll().where("id", "=", data.id).executeTakeFirstOrThrow();
+      })
+    )
+  });
+  const _updateTag = withCodec({
+    encoder: StudioCMSPageDataTags.Update,
+    decoder: StudioCMSPageDataTags.Select,
+    callbackFn: (db, data) => db(
+      (client) => client.transaction().execute(async (trx) => {
+        await trx.updateTable("StudioCMSPageDataTags").set(data).where("id", "=", data.id).executeTakeFirstOrThrow();
+        return await trx.selectFrom("StudioCMSPageDataTags").selectAll().where("id", "=", data.id).executeTakeFirstOrThrow();
+      })
+    )
+  });
+  const _updateCategory = withCodec({
+    encoder: StudioCMSPageDataCategories.Update,
+    decoder: StudioCMSPageDataCategories.Select,
+    callbackFn: (db, data) => db(
+      (client) => client.transaction().execute(async (trx) => {
+        await trx.updateTable("StudioCMSPageDataCategories").set(data).where("id", "=", data.id).executeTakeFirstOrThrow();
+        return await trx.selectFrom("StudioCMSPageDataCategories").selectAll().where("id", "=", data.id).executeTakeFirstOrThrow();
+      })
+    )
+  });
+  const _updatePermission = withCodec({
+    encoder: StudioCMSPermissions.Update,
+    decoder: StudioCMSPermissions.Select,
+    callbackFn: (db, data) => db(
+      (client) => client.transaction().execute(async (trx) => {
+        await trx.updateTable("StudioCMSPermissions").set(data).where("user", "=", data.user).executeTakeFirstOrThrow();
+        return await trx.selectFrom("StudioCMSPermissions").selectAll().where("user", "=", data.user).executeTakeFirstOrThrow();
+      })
+    )
+  });
+  const _updateFolderEntry = withCodec({
+    encoder: StudioCMSPageFolderStructure.Update,
+    decoder: StudioCMSPageFolderStructure.Select,
+    callbackFn: (db, data) => db(
+      (client) => client.transaction().execute(async (trx) => {
+        await trx.updateTable("StudioCMSPageFolderStructure").set(data).where("id", "=", data.id).executeTakeFirstOrThrow();
+        return await trx.selectFrom("StudioCMSPageFolderStructure").selectAll().where("id", "=", data.id).executeTakeFirstOrThrow();
+      })
+    )
+  });
+  const _updatePageDataEntry = withCodec({
+    encoder: StudioCMSPageData.Update,
+    decoder: StudioCMSPageData.Select,
+    callbackFn: (db, data) => db(
+      (client) => client.transaction().execute(async (trx) => {
+        await trx.updateTable("StudioCMSPageData").set(data).where("id", "=", data.id).executeTakeFirstOrThrow();
+        return await trx.selectFrom("StudioCMSPageData").selectAll().where("id", "=", data.id).executeTakeFirstOrThrow();
+      })
+    )
+  });
+  const _findPageDataBySlug = withCodec({
+    encoder: Schema.String,
+    decoder: StudioCMSPageData.Select,
+    callbackFn: (db, slug) => db(
+      (client) => client.selectFrom("StudioCMSPageData").where("slug", "=", slug).selectAll().executeTakeFirstOrThrow()
+    )
+  });
+  const _updateFolderTree = CLEAR.folderTree.pipe(Effect.flatMap(GET.folderTree));
+  const _updateFolderList = CLEAR.folderList.pipe(Effect.flatMap(GET.folderList));
+  const _updateFolderEntryAndInvalidate = Effect.fn(
+    (data) => _updateFolderEntry(data).pipe(
+      Effect.flatMap((src) => _updateFolderTree.pipe(Effect.as(src))),
+      Effect.flatMap((src) => _updateFolderList.pipe(Effect.as(src)))
+    )
+  );
+  const _updateLatestVersion = Effect.fn(
+    () => CACHE.invalidateTags(cacheTags.npmPackage).pipe(Effect.flatMap(GET.latestVersion))
+  );
+  const _updateFolderTreeAndList = Effect.all([_updateFolderTree, _updateFolderList]);
+  const _updatePageById = Effect.fn(
+    (pageId, data) => Effect.all([
+      _updatePageDataEntry(data.pageData),
+      _updatePageContent(data.pageContent),
+      CACHE.delete(cacheKeyGetters.page(pageId))
+    ]).pipe(
+      Effect.tap(() => _updateFolderTreeAndList),
+      Effect.flatMap(() => GET.page.byId(pageId))
+    )
+  );
+  const _findPageIdBySlug = Effect.fn(
+    (slug) => _findPageDataBySlug(slug).pipe(Effect.map(({ id }) => id))
+  );
+  const _updatePageByIdPiped = (data) => Effect.fn((id) => _updatePageById(id, data));
+  const _updatePageBySlug = Effect.fn(
+    (slug, data) => _findPageIdBySlug(slug).pipe(Effect.flatMap(_updatePageByIdPiped(data)))
+  );
+  const UPDATE = {
+    /**
+     * Update Page Content
+     *
+     * @param data - The page content data to update.
+     * @returns The updated page content.
+     */
+    pageContent: _updatePageContent,
+    /**
+     * Update Tag
+     *
+     * @param data - The tag data to update.
+     * @returns The updated tag.
+     */
+    tags: _updateTag,
+    /**
+     * Update Category
+     *
+     * @param data - The category data to update.
+     * @returns The updated category.
+     */
+    categories: _updateCategory,
+    /**
+     * Update Permissions
+     *
+     * @param data - The permissions data to update.
+     * @returns The updated permissions.
+     */
+    permissions: _updatePermission,
+    /**
+     * Update Folder Tree Cache
+     */
+    folderTree: _updateFolderTree,
+    /**
+     * Update Folder List Cache
+     */
+    folderList: _updateFolderList,
+    /**
+     * Update Folder Entry and Invalidate Related Caches
+     *
+     * @param data - The folder entry data to update.
+     * @returns The updated folder entry.
+     */
+    folder: _updateFolderEntryAndInvalidate,
+    /**
+     * Update Latest NPM Package Version
+     */
+    latestVersion: _updateLatestVersion,
+    /**
+     * Update Site Configuration
+     */
+    siteConfig: CONFIG.siteConfig.update,
+    /**
+     * Page Operations
+     */
+    page: {
+      /**
+       * Update Page by ID
+       */
+      byId: _updatePageById,
+      /**
+       * Update Page by Slug
+       */
+      bySlug: _updatePageBySlug
+    }
+  };
+  return UPDATE;
+});
+var update_default = SDKUpdateModule;
+export {
+  SDKUpdateModule,
+  update_default as default
+};

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

@@ -0,0 +1,125 @@
+import { Effect, type ParseResult } from '@withstudiocms/effect';
+import type { DBCallbackFailure } from '@withstudiocms/kysely/client';
+import type { DatabaseError } from '@withstudiocms/kysely/core/errors';
+import { DBClientLive, StorageManagerResolver } 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 number[]) => Effect.Effect<readonly {
+        readonly id: number;
+        readonly name: string;
+        readonly description: string;
+        readonly parent?: number | null | undefined;
+        readonly slug: string;
+        readonly meta: {
+            readonly [x: string]: unknown;
+        };
+    }[], DBCallbackFailure | DatabaseError, never>;
+    collectTags: (input: readonly number[]) => Effect.Effect<readonly {
+        readonly id: number;
+        readonly name: string;
+        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 id: string;
+        readonly url?: string | null | undefined;
+        readonly name: string;
+        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 | StorageManagerResolver>;
+export {};