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

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

@@ -0,0 +1,236 @@
+import { Effect } from '@withstudiocms/effect';
+/**
+ * SDK Util Module
+ *
+ * This module aggregates various utility functionalities of the SDK.
+ */
+export declare const SDKUtilModule: Effect.Effect<{
+    Collectors: {
+        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;
+            };
+        }[], import("@withstudiocms/kysely").DBCallbackFailure | import("@withstudiocms/kysely/core/errors").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;
+            };
+        }[], import("@withstudiocms/kysely").DBCallbackFailure | import("@withstudiocms/kysely/core/errors").DatabaseError, never>;
+        collectPageData: {
+            (page: import("../../types.js").tsPageDataSelect, tree: import("../../types.js").FolderNode[]): Effect.Effect<import("../../types.js").CombinedPageData, import("./collectors.js").CollectorError | import("./folderTree.js").FolderTreeError | import("@withstudiocms/kysely").DBCallbackFailure | import("@withstudiocms/kysely/core/errors").DatabaseError | import("effect/ParseResult").ParseError, never>;
+            (page: import("../../types.js").tsPageDataSelect, tree: import("../../types.js").FolderNode[], metaOnly: boolean): Effect.Effect<import("../../types.js").MetaOnlyPageData, import("./collectors.js").CollectorError | import("./folderTree.js").FolderTreeError | import("@withstudiocms/kysely").DBCallbackFailure | import("@withstudiocms/kysely/core/errors").DatabaseError | import("effect/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<import("../../types.js").CombinedUserData, import("@withstudiocms/kysely").DBCallbackFailure | import("@withstudiocms/kysely/core/errors").DatabaseError, never>;
+    };
+    FolderTree: {
+        generateFolderTree: (folders: readonly {
+            readonly name: string;
+            readonly id: string;
+            readonly parent: string | null | undefined;
+        }[]) => Effect.Effect<import("../../types.js").FolderNode[], import("./folderTree.js").FolderTreeError, never>;
+        getFullPath: (tree: import("../../types.js").FolderNode[], path: string[]) => Effect.Effect<string[], import("./folderTree.js").FolderTreeError, never>;
+        findNodeByPath: (tree: import("../../types.js").FolderNode[], path: string[]) => Effect.Effect<import("../../types.js").FolderNode | null, import("./folderTree.js").FolderTreeError, never>;
+        findNodesAlongPath: (tree: import("../../types.js").FolderNode[], path: string[]) => Effect.Effect<import("../../types.js").FolderNode[], import("./folderTree.js").FolderTreeError, never>;
+        findNodesAlongPathToId: (tree: import("../../types.js").FolderNode[], id: string) => Effect.Effect<import("../../types.js").FolderNode[], import("./folderTree.js").FolderTreeError, never>;
+        findNodeById: (tree: import("../../types.js").FolderNode[], id: string) => Effect.Effect<import("../../types.js").FolderNode | null, import("./folderTree.js").FolderTreeError, never>;
+        addPageToFolderTree: (tree: import("../../types.js").FolderNode[], folderId: string, newPage: import("../../types.js").FolderNode) => Effect.Effect<import("../../types.js").FolderNode[], import("./folderTree.js").FolderTreeError, never>;
+        buildFolderTree: Effect.Effect<import("../../types.js").FolderNode[], import("@withstudiocms/kysely").DBCallbackFailure | import("@withstudiocms/kysely/core/errors").DatabaseError | import("./folderTree.js").FolderTreeError, never>;
+        getAvailableFolders: Effect.Effect<import("../../types.js").FolderListItem[], import("@withstudiocms/kysely").DBCallbackFailure | import("@withstudiocms/kysely/core/errors").DatabaseError, never>;
+    };
+    Generators: {
+        generateRandomIDNumber: (length: number) => Effect.Effect<number, import("./generators.js").GeneratorError, never>;
+        generateRandomPassword: (length: number) => Effect.Effect<string, import("./generators.js").GeneratorError, never>;
+        generateToken: (userId: string, noExpire?: boolean | undefined) => Effect.Effect<string, import("./generators.js").GeneratorError, never>;
+        testToken: (token: string) => Effect.Effect<import("../../types.js").JwtVerificationResult, import("./generators.js").GeneratorError, never>;
+    };
+    GetFromNPM: {
+        getVersion: (pkg: string, ver?: string | undefined) => Effect.Effect<{
+            version: string;
+            lastCacheUpdate: Date;
+        }, import("effect/Cause").UnknownException | Error | import("effect/ParseResult").ParseError, never>;
+        getDataFromNPM: (pkg: string, ver?: string | undefined) => Effect.Effect<import("./getFromNPM.js").NpmRegistryResponseSchema, import("effect/Cause").UnknownException | Error | import("effect/ParseResult").ParseError, never>;
+    };
+    Parsers: {
+        parseIdNumberArray: (ids: unknown) => Effect.Effect<readonly number[], import("effect/ParseResult").ParseError, never>;
+        parseIdStringArray: (ids: unknown) => Effect.Effect<readonly string[], import("effect/ParseResult").ParseError, never>;
+        fixDiff: <T extends import("../../types.js").diffItem | import("../../types.js").diffItem[]>(items: T) => Effect.Effect<import("../../types.js").DiffReturnType<T>, import("./parsers.js").ParsersError, never>;
+    };
+    Users: {
+        verifyRank: (users: readonly {
+            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;
+        }[], permissions: readonly {
+            readonly user: string;
+            readonly rank: "owner" | "admin" | "editor" | "visitor" | "unknown";
+        }[], rank: string) => Effect.Effect<import("../../types.js").SingleRank[], import("./users.js").UsersError, never>;
+        combineRanks: (rank: string, users: import("../../types.js").SingleRank[]) => Effect.Effect<import("../../types.js").CombinedRank[], import("./users.js").UsersError, never>;
+        clearUserReferences: (userId: string) => Effect.Effect<boolean, import("@withstudiocms/kysely").DBCallbackFailure | import("@withstudiocms/kysely/core/errors").QueryError | import("@withstudiocms/kysely/core/errors").NotFoundError, never>;
+    };
+}, import("effect/ConfigError").ConfigError, import("../../context.js").DBClientLive | import("../../context.js").SDKDefaults | import("../../cache.js").CacheService>;
+export default SDKUtilModule;

package/dist/modules/util/index.js

@@ -0,0 +1,20 @@
+import { Effect } from "@withstudiocms/effect";
+import { SDKCollectors as Collectors } from "./collectors.js";
+import { SDKFolderTree as FolderTree } from "./folderTree.js";
+import { SDKGenerators as Generators } from "./generators.js";
+import { GetFromNPM } from "./getFromNPM.js";
+import { SDKParsers as Parsers } from "./parsers.js";
+import { SDKUsers as Users } from "./users.js";
+const SDKUtilModule = Effect.all({
+  Collectors,
+  FolderTree,
+  Generators,
+  GetFromNPM,
+  Parsers,
+  Users
+});
+var util_default = SDKUtilModule;
+export {
+  SDKUtilModule,
+  util_default as default
+};

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

@@ -0,0 +1,60 @@
+import { Effect } from '@withstudiocms/effect';
+import type { DiffReturnType, diffItem } from '../../types.js';
+declare const ParsersError_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: "ParsersError";
+} & Readonly<A>;
+/**
+ * Error class for parser errors.
+ */
+export declare class ParsersError extends ParsersError_base<{
+    cause: unknown;
+}> {
+}
+/**
+ * Utility function to handle errors in parser 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 ParsersError.
+ */
+export declare const useParsersError: <T>(_try: () => T) => Effect.Effect<T, ParsersError, never>;
+/**
+ * SDKParsers
+ *
+ * Produces a collection of Effect-aware parser utilities used by the SDK.
+ *
+ * The returned object contains three helpers:
+ * - parseIdNumberArray(ids): Parses an unknown value into an array of numbers using the
+ *   SDK's NumberArraySchema and returns an Effect that yields the parsed array or a parse error.
+ * - parseIdStringArray(ids): Parses an unknown value into an array of strings using the
+ *   SDK's StringArraySchema and returns an Effect that yields the parsed array or a parse error.
+ * - fixDiff(items): Accepts a single diff item or an array of diff items and returns an Effect
+ *   that yields the same shape with the `pageMetaData` field parsed from a JSON string into an
+ *   object shaped as { start: Partial<tsPageDataSelect>, end: Partial<tsPageDataSelect> }.
+ *
+ * @remarks
+ * - Each helper is implemented as an Effect.fn so callers receive an Effect that encapsulates
+ *   parsing work and errors.
+ * - fixDiff uses JSON.parse on the pageMetaData field and wraps failures using the SDK's parser
+ *   error handling, so JSON or schema parsing problems are surfaced as a ParsersError.
+ * - The functions preserve all other fields on the diff items while only transforming pageMetaData.
+ *
+ * @typeParam T - For fixDiff: the input type, constrained to either a single diffItem or an array of diffItem.
+ *
+ * @returns An object with three properties:
+ * - parseIdNumberArray: (ids: unknown) => Effect<..., number[], ...> — yields a number array on success.
+ * - parseIdStringArray: (ids: unknown) => Effect<..., string[], ...> — yields a string array on success.
+ * - fixDiff: <T extends diffItem | diffItem[]>(items: T) => Effect<..., DiffReturnType<T>, ...> —
+ *   yields the input diff item(s) with parsed pageMetaData.
+ *
+ * @example
+ * // (pseudo-code demonstrating usage in an Effect context)
+ * const parsers = yield* SDKParsers;
+ * const numbers = yield* parsers.parseIdNumberArray(someUnknown);
+ * const fixed = yield* parsers.fixDiff(someDiffOrArray);
+ */
+export declare const SDKParsers: Effect.Effect<{
+    parseIdNumberArray: (ids: unknown) => Effect.Effect<readonly number[], import("effect/ParseResult").ParseError, never>;
+    parseIdStringArray: (ids: unknown) => Effect.Effect<readonly string[], import("effect/ParseResult").ParseError, never>;
+    fixDiff: <T extends diffItem | diffItem[]>(items: T) => Effect.Effect<DiffReturnType<T>, ParsersError, never>;
+}, never, never>;
+export {};

package/dist/modules/util/parsers.js

@@ -0,0 +1,43 @@
+import { Data, Effect, Schema } from "@withstudiocms/effect";
+class ParsersError extends Data.TaggedError("ParsersError") {
+}
+const useParsersError = (_try) => Effect.try({
+  try: _try,
+  catch: (cause) => new ParsersError({ cause })
+});
+const SDKParsers = Effect.gen(function* () {
+  const parseIdNumberArray = Effect.fn(
+    (ids) => Schema.decodeUnknown(Schema.Array(Schema.Number))(ids)
+  );
+  const parseIdStringArray = Effect.fn(
+    (ids) => Schema.decodeUnknown(Schema.Array(Schema.String))(ids)
+  );
+  const fixDiff = Effect.fn(
+    (items) => useParsersError(() => {
+      if (Array.isArray(items)) {
+        const toReturn = [];
+        for (const { pageMetaData, ...rest } of items) {
+          toReturn.push({
+            ...rest,
+            pageMetaData
+          });
+        }
+        return toReturn;
+      }
+      return {
+        ...items,
+        pageMetaData: items.pageMetaData
+      };
+    })
+  );
+  return {
+    parseIdNumberArray,
+    parseIdStringArray,
+    fixDiff
+  };
+});
+export {
+  ParsersError,
+  SDKParsers,
+  useParsersError
+};

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

@@ -0,0 +1,22 @@
+/**
+ * Options for the slugify function
+ */
+export interface SlugifyOptions {
+    /**
+     * The separator to use in the slug
+     * @default '-'
+     */
+    separator?: string;
+    /**
+     * Whether to convert the slug to lowercase
+     * @default true
+     */
+    lowercase?: boolean;
+}
+/**
+ * Converts a string into a URL-safe slug
+ * @param text - The text to slugify
+ * @param options - Optional configuration
+ * @returns A URL-safe slug string
+ */
+export declare function slugify(text: string, options?: SlugifyOptions): string;

package/dist/modules/util/slugify.js

@@ -0,0 +1,19 @@
+function escapeRegExp(str) {
+  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function emptyStringToUndefined(value) {
+  return value.trim() === "" ? void 0 : value;
+}
+function slugify(text, options = {}) {
+  const { separator: rawSeparator = "-", lowercase = true } = options;
+  const separator = emptyStringToUndefined(rawSeparator) || "-";
+  const escapedSeparator = escapeRegExp(separator);
+  let slug = text.toString().normalize("NFD").replace(/[\u0300-\u036f]/g, "").replace(new RegExp(`[^a-zA-Z0-9\\s${escapedSeparator}]`, "g"), "").trim().replace(/\s+/g, separator).replace(new RegExp(`(?:${escapedSeparator})+`, "g"), separator);
+  if (lowercase) {
+    slug = slug.toLowerCase();
+  }
+  return slug;
+}
+export {
+  slugify
+};

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

@@ -0,0 +1,99 @@
+import { Effect } from '@withstudiocms/effect';
+import { DBClientLive, SDKDefaults } from '../../context.js';
+import type { CombinedRank, SingleRank } from '../../types.js';
+declare const UsersError_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: "UsersError";
+} & Readonly<A>;
+/**
+ * Custom error class for user-related operations in the SDK.
+ */
+export declare class UsersError extends UsersError_base<{
+    cause: unknown;
+}> {
+}
+/**
+ * Helper function to wrap user-related operations with error handling.
+ *
+ * @param _try - A function that performs the desired operation.
+ * @returns An Effect that either succeeds with the result of the operation or fails with a UsersError.
+ */
+export declare const useUsersError: <T>(_try: () => T) => Effect.Effect<T, UsersError, never>;
+/**
+ * SDKUsers
+ *
+ * An Effect-based service that provides user-related utility functions for verifying ranks,
+ * combining rank metadata, and clearing all database references to a user.
+ *
+ * This Effect generator depends on SDKDefaults and DBClientLive to obtain:
+ * - GhostUserDefaults: used as the fallback/ghost user id when reassigning records
+ * - effectDb: an Effect wrapper around the database client used for queries/updates
+ *
+ * The yielded object contains the following functions:
+ *
+ * - verifyRank(users, permissions, rank)
+ *   - Purpose: Determine which users from a provided user list hold a specific rank based
+ *     on a permissions collection.
+ *   - Parameters:
+ *     - users: an array of user rows/objects (tsUsersSelect[]), expected to include `id` and `name`.
+ *     - permissions: an array of permission rows/objects (tsPermissions['Select']['Type'][]) that include a `user` reference and a `rank` string.
+ *     - rank: the rank string to filter by.
+ *   - Behavior: Filters the permissions by the provided rank, finds the corresponding user
+ *     objects by id from the `users` array, and returns an array of SingleRank objects
+ *     ({ id, name }) for the matching users.
+ *   - Errors: Execution is wrapped in the users error handling helper (useUsersError), so
+ *     input or mapping errors are surfaced through that wrapper.
+ *
+ * - combineRanks(rank, users)
+ *   - Purpose: Attach a rank to a set of SingleRank entries, producing CombinedRank entries.
+ *   - Parameters:
+ *     - rank: the rank string to assign to each user.
+ *     - users: an array of SingleRank objects (each with `id` and `name`).
+ *   - Behavior: Returns a new array where each user object is shallow-copied and augmented
+ *     with the provided `rank` property. Execution is wrapped in useUsersError for consistent error handling.
+ *
+ * - clearUserReferences(userId)
+ *   - Purpose: Remove or reassign all database references to a user when that user must be
+ *     cleaned up (e.g., account deletion).
+ *   - Parameters:
+ *     - userId: the id of the user whose references should be removed or reassigned.
+ *   - Behavior: Performs a sequence of effectful DB operations (via effectDb):
+ *     1. Deletes reset tokens from StudioCMSUserResetTokens for the userId.
+ *     2. Deletes OAuth accounts from StudioCMSOAuthAccounts for the userId.
+ *     3. Deletes permission rows from StudioCMSPermissions for the userId.
+ *     4. Deletes session rows from StudioCMSSessionTable for the userId.
+ *     5. Updates StudioCMSDiffTracking rows to set `userId` => GhostUserDefaults.id where they referenced the deleted user.
+ *     6. Updates StudioCMSPageData rows to set `authorId` => GhostUserDefaults.id where they referenced the deleted user.
+ *     - Each DB call uses executeTakeFirstOrThrow semantics, so failures in any step will throw.
+ *   - Returns: A boolean true on successful completion of all operations.
+ *
+ * Notes:
+ * - SDKUsers itself is an Effect value; consumers must run/interpret the Effect to obtain the utilities.
+ * - verifyRank and combineRanks are lightweight, in-memory operations wrapped with the users error helper;
+ *   clearUserReferences performs real database operations and may throw on failure.
+ *
+ * Example:
+ * @example
+ * const usersEffect = SDKUsers; // Effect that yields { verifyRank, combineRanks, clearUserReferences }
+ * // run the effect in your runtime to access the utilities and then call the functions as needed.
+ */
+export declare const SDKUsers: Effect.Effect<{
+    verifyRank: (users: readonly {
+        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;
+    }[], permissions: readonly {
+        readonly user: string;
+        readonly rank: "owner" | "admin" | "editor" | "visitor" | "unknown";
+    }[], rank: string) => Effect.Effect<SingleRank[], UsersError, never>;
+    combineRanks: (rank: string, users: SingleRank[]) => Effect.Effect<CombinedRank[], UsersError, never>;
+    clearUserReferences: (userId: string) => Effect.Effect<boolean, import("@withstudiocms/kysely").DBCallbackFailure | import("@withstudiocms/kysely/core/errors").QueryError | import("@withstudiocms/kysely/core/errors").NotFoundError, never>;
+}, never, DBClientLive | SDKDefaults>;
+export {};

package/dist/modules/util/users.js

@@ -0,0 +1,78 @@
+import { Data, Effect } from "@withstudiocms/effect";
+import { DBClientLive, SDKDefaults } from "../../context.js";
+class UsersError extends Data.TaggedError("UsersError") {
+}
+const useUsersError = (_try) => Effect.try({
+  try: _try,
+  catch: (error) => new UsersError({ cause: error })
+});
+const SDKUsers = Effect.gen(function* () {
+  const [{ GhostUserDefaults }, { effectDb }] = yield* Effect.all([SDKDefaults, DBClientLive]);
+  const verifyRank = Effect.fn(
+    (users, permissions, rank) => useUsersError(() => {
+      const filteredUsers = permissions.filter((user) => user.rank === rank);
+      const permitted = [];
+      for (const user of filteredUsers) {
+        const foundUser = users.find((u) => u.id === user.user);
+        if (foundUser) {
+          permitted.push({ id: foundUser.id, name: foundUser.name });
+        }
+      }
+      return permitted;
+    })
+  );
+  const combineRanks = Effect.fn(
+    (rank, users) => useUsersError(() => users.map((user) => ({ ...user, rank })))
+  );
+  const clearUserReferences = Effect.fn(function* (userId) {
+    yield* Effect.all([
+      ...[
+        {
+          table: "StudioCMSUserResetTokens",
+          lhs: "userId"
+        },
+        {
+          table: "StudioCMSOAuthAccounts",
+          lhs: "userId"
+        },
+        {
+          table: "StudioCMSPermissions",
+          lhs: "user"
+        },
+        {
+          table: "StudioCMSSessionTable",
+          lhs: "userId"
+        }
+      ].map(
+        ({ table, lhs }) => effectDb((db) => db.deleteFrom(table).where(lhs, "=", userId).executeTakeFirstOrThrow())
+      ),
+      ...[
+        {
+          table: "StudioCMSDiffTracking",
+          lhs: "userId",
+          update: { userId: GhostUserDefaults.id }
+        },
+        {
+          table: "StudioCMSPageData",
+          lhs: "authorId",
+          update: { authorId: GhostUserDefaults.id }
+        }
+      ].map(
+        ({ table, lhs, update }) => effectDb(
+          (db) => db.updateTable(table).set(update).where(lhs, "=", userId).executeTakeFirstOrThrow()
+        )
+      )
+    ]);
+    return true;
+  });
+  return {
+    verifyRank,
+    combineRanks,
+    clearUserReferences
+  };
+});
+export {
+  SDKUsers,
+  UsersError,
+  useUsersError
+};