@pelatform/starter.db 0.1.0

package/README.md

@@ -0,0 +1,5 @@
+# Pelatform Starter
+
+A part of SaaS starter kit for Pelatform applications.
+
+[![Version](https://img.shields.io/npm/v/@pelatform/starter.svg)](https://www.npmjs.com/package/@pelatform/starter)

package/dist/index.d.ts

@@ -0,0 +1,219 @@
+declare const prefixes: readonly ["acc_", "api_", "ct_", "cus_", "dev_", "elog_", "org_", "invi_", "mem_", "pass_", "prod_", "proj_", "rt_", "sess_", "subs_", "two_", "user_", "ver_", "wh_", "ws_"];
+declare const createId: ({ prefix }: {
+    prefix: (typeof prefixes)[number];
+}) => string;
+declare const createIdCustom: ({ prefix }: {
+    prefix: string;
+}) => string;
+
+/**
+ * Creates a new email log entry in the database.
+ *
+ * This function logs email events (e.g., sent emails) with associated metadata
+ * for tracking and auditing purposes.
+ *
+ * @param db - The database client instance (e.g., PrismaClient).
+ * @param email - The recipient's email address.
+ * @param metadata - Additional metadata related to the email (e.g., subject, template ID).
+ * @returns A promise that resolves when the log is created.
+ */
+declare function createEmailLog(db: any, email: string, metadata: any): Promise<void>;
+
+/**
+ * Retrieves user details from the database.
+ *
+ * Fetches the user based on the session ID, including their role and active workspace
+ * based on the current session's active organization.
+ *
+ * @param db - The database client instance.
+ * @param session - The current user session object.
+ * @param customSelect - Optional Prisma select object to customize returned fields.
+ * @returns The user object with role and active workspace, or an error object.
+ */
+declare function getUser(db: any, session: any, customSelect?: any): Promise<any>;
+/**
+ * Updates a user's information in the database.
+ *
+ * Updates the user record identified by the session ID with the provided data.
+ * Returns the updated user object with role and active workspace information.
+ *
+ * @param db - The database client instance.
+ * @param session - The current user session object.
+ * @param data - The data to update (key-value pairs).
+ * @param customSelect - Optional Prisma select object to customize returned fields.
+ * @returns The updated user object with role and active workspace, or an error object.
+ */
+declare function updateUser(db: any, session: any, data: Record<string, any>, customSelect?: any): Promise<any>;
+/**
+ * Updates a specific user's data by their ID.
+ *
+ * Direct database update for a user without session context.
+ *
+ * @param db - The database client instance.
+ * @param userId - The ID of the user to update.
+ * @param data - The data to update.
+ * @returns
+ */
+declare function updateUserData(db: any, userId: string, data: Record<string, any>): Promise<void>;
+/**
+ * Fetches initial user data for app initialization.
+ *
+ * Retrieves the user and their membership details for the active organization
+ * stored in the session.
+ *
+ * @param db - The database client instance.
+ * @param session - The current user session object.
+ * @returns Object containing user data and authentication status.
+ */
+declare function getInitialUserData(db: any, session: any): Promise<{
+    user: any;
+    isAuthenticated: boolean;
+}>;
+
+/**
+ * Retrieves a workspace by its slug.
+ *
+ * Fetches workspace details if the user is a member of the workspace.
+ * Includes the current user's role in the returned data.
+ *
+ * @param db - The database client instance.
+ * @param session - The current user session.
+ * @param slug - The unique slug of the workspace.
+ * @param customSelect - Optional Prisma select object.
+ * @returns The workspace object with currentUserRole, or an error object.
+ */
+declare function getWorkspacebySlug(db: any, session: any, slug: string, customSelect?: any): Promise<any>;
+/**
+ * Retrieves a list of workspaces the user is a member of.
+ *
+ * @param db - The database client instance.
+ * @param session - The current user session.
+ * @param customSelect - Optional Prisma select object.
+ * @returns Array of workspace objects with currentUserRole, or an error object.
+ */
+declare function getWorkspaceList(db: any, session: any, customSelect?: any): Promise<any>;
+/**
+ * Fetches the initial workspace data for the active user.
+ *
+ * If a workspace slug is provided, the function attempts to fetch
+ * that workspace (checking membership). Otherwise, it falls back
+ * to the user's currently active session workspace.
+ *
+ * @param db - The database client instance.
+ * @param session - The user session object containing active workspace ID.
+ * @param customSelect - Optional Prisma select object.
+ * @returns The workspace data or null if not found.
+ */
+declare function getInitialWorkspaceData(db: any, session: any, customSelect?: any): Promise<any>;
+/**
+ * Determines which workspace should be activated for a given user.
+ *
+ * The function checks, in order:
+ *  1. The user's **last visited workspace** (stored in cookies), verifying they still have access to it.
+ *  2. If not found or access was lost, the first workspace where the user is an **owner**.
+ *  3. If still none, the first workspace where the user is a **member**.
+ *
+ * Returns the workspace's `slug` and `id`, or `undefined` if the user has no accessible workspaces.
+ *
+ * @param db - The database client instance.
+ * @param userId - The ID of the user to look up workspaces for.
+ * @param slug - Optional workspace slug to check if user still has access.
+ * @returns An object containing `{ slug, id }` for the selected workspace, or `undefined` if none found.
+ */
+declare function getLastActiveWorkspace(db: any, userId: string, slug?: string): Promise<{
+    slug: string;
+    id: string;
+} | undefined>;
+/**
+ * Validates whether the given workspace slug exists and the active user has access to it.
+ *
+ * @param db - The database client instance.
+ * @param session - The current user session.
+ * @param slug - The workspace slug to validate.
+ * @returns {Promise<boolean>} True if the workspace exists and the user is a member.
+ */
+declare function validateWorkspaceAccess(db: any, session: any, slug: string): Promise<boolean>;
+
+/** Reusable Prisma select object for user queries */
+declare const userSelect: (workspaceId: string) => {
+    readonly id: true;
+    readonly name: true;
+    readonly email: true;
+    readonly image: true;
+    readonly emailVerified: true;
+    readonly createdAt: true;
+    readonly updatedAt: true;
+    readonly members: {
+        readonly where: {
+            readonly organizationId: string;
+        };
+        readonly select: {
+            readonly role: true;
+            readonly organization: {
+                readonly select: {
+                    readonly id: true;
+                    readonly name: true;
+                    readonly slug: true;
+                };
+            };
+        };
+        readonly take: 1;
+    };
+};
+
+/** Reusable Prisma select object for workspace queries */
+declare const workspaceSelect: {
+    readonly id: true;
+    readonly name: true;
+    readonly slug: true;
+    readonly logo: true;
+    readonly metadata: true;
+    readonly createdAt: true;
+    readonly members: {
+        readonly select: {
+            readonly id: true;
+            readonly organizationId: true;
+            readonly userId: true;
+            readonly role: true;
+            readonly createdAt: true;
+            readonly user: {
+                readonly select: {
+                    readonly id: true;
+                    readonly name: true;
+                    readonly email: true;
+                    readonly image: true;
+                };
+            };
+        };
+    };
+    readonly invitations: {
+        readonly select: {
+            readonly id: true;
+            readonly organizationId: true;
+            readonly inviterId: true;
+            readonly email: true;
+            readonly role: true;
+            readonly status: true;
+            readonly expiresAt: true;
+        };
+    };
+    readonly subscription: {
+        readonly select: {
+            readonly id: true;
+            readonly userId: true;
+            readonly workspaceId: true;
+            readonly subscriptionId: true;
+            readonly externalId: true;
+            readonly provider: true;
+            readonly status: true;
+            readonly plan: true;
+            readonly currentPeriodStart: true;
+            readonly currentPeriodEnd: true;
+            readonly cancelAtPeriodEnd: true;
+            readonly canceledAt: true;
+            readonly isLifetime: true;
+        };
+    };
+};
+
+export { createEmailLog, createId, createIdCustom, getInitialUserData, getInitialWorkspaceData, getLastActiveWorkspace, getUser, getWorkspaceList, getWorkspacebySlug, updateUser, updateUserData, userSelect, validateWorkspaceAccess, workspaceSelect };

package/dist/index.js

@@ -0,0 +1,388 @@
+// src/lib/create-id.ts
+import crypto from "crypto";
+import baseX from "base-x";
+var base32 = baseX("0123456789ABCDEFGHJKMNPQRSTVWXYZ");
+function createULIDBuffer() {
+  const buf = new Uint8Array(16);
+  const timestamp = BigInt(Date.now());
+  buf[0] = Number(timestamp >> BigInt(40) & BigInt(255));
+  buf[1] = Number(timestamp >> BigInt(32) & BigInt(255));
+  buf[2] = Number(timestamp >> BigInt(24) & BigInt(255));
+  buf[3] = Number(timestamp >> BigInt(16) & BigInt(255));
+  buf[4] = Number(timestamp >> BigInt(8) & BigInt(255));
+  buf[5] = Number(timestamp & BigInt(255));
+  crypto.getRandomValues(buf.subarray(6));
+  return buf;
+}
+var createId = ({ prefix }) => {
+  const buf = createULIDBuffer();
+  const id = base32.encode(buf);
+  return `${prefix}${id}`;
+};
+var createIdCustom = ({ prefix }) => {
+  const buf = createULIDBuffer();
+  const id = base32.encode(buf);
+  return `${prefix}${id}`;
+};
+
+// src/queries/email-log.ts
+async function createEmailLog(db, email, metadata) {
+  await db.emailLog.create({
+    data: {
+      email,
+      metadata
+    }
+  });
+}
+
+// src/utils/user-select.ts
+var userSelect = (workspaceId) => ({
+  id: true,
+  name: true,
+  email: true,
+  image: true,
+  emailVerified: true,
+  createdAt: true,
+  updatedAt: true,
+  members: {
+    where: {
+      organizationId: workspaceId
+    },
+    select: {
+      role: true,
+      organization: {
+        select: {
+          id: true,
+          name: true,
+          slug: true
+        }
+      }
+    },
+    take: 1
+  }
+});
+
+// src/queries/user.ts
+async function getUser(db, session, customSelect) {
+  if (!session || !session.user) {
+    return { error: true, message: "User not authenticated" };
+  }
+  try {
+    const result = await db.user.findUnique({
+      where: { id: session?.user.id },
+      select: customSelect || userSelect(session?.session?.activeOrganizationId || "")
+    });
+    if (!result) {
+      return { error: true, message: "User not found" };
+    }
+    const user = {
+      ...result,
+      workspaceRole: result?.members[0]?.role || null,
+      activeWorkspace: result?.members[0]?.organization || null
+    };
+    return user;
+  } catch (error) {
+    console.error("Error fetching user data:", error);
+    return { error: true, message: "Error fetching user data." };
+  }
+}
+async function updateUser(db, session, data, customSelect) {
+  if (!session || !session.user) {
+    return { error: true, message: "User not authenticated" };
+  }
+  try {
+    const result = await db.user.update({
+      where: { id: session?.user.id },
+      data,
+      select: customSelect || userSelect(session?.session?.activeOrganizationId || "")
+    });
+    if (!result) {
+      return { error: true, message: "User not found" };
+    }
+    const user = {
+      ...result,
+      workspaceRole: result?.members[0]?.role || null,
+      activeWorkspace: result?.members[0]?.organization || null
+    };
+    return user;
+  } catch (error) {
+    console.error("Error updating user data:", error);
+    return { error: true, message: "Error updating user data." };
+  }
+}
+async function updateUserData(db, userId, data) {
+  if (!userId) {
+    return;
+  }
+  await db.user.update({
+    where: { id: userId },
+    data
+  });
+}
+async function getInitialUserData(db, session) {
+  if (!session || !session.user) {
+    return { user: null, isAuthenticated: false };
+  }
+  try {
+    const result = await db.user.findUnique({
+      where: { id: session.user.id }
+    });
+    if (!result) {
+      return { user: null, isAuthenticated: false };
+    }
+    const activeOrganizationId = session.session?.activeOrganizationId;
+    if (activeOrganizationId && typeof activeOrganizationId !== "string") {
+      console.warn("Invalid activeOrganizationId type:", typeof activeOrganizationId);
+      return { user: null, isAuthenticated: true };
+    }
+    const member = activeOrganizationId ? await db.member.findFirst({
+      where: {
+        organizationId: activeOrganizationId,
+        userId: result.id
+      },
+      include: {
+        organization: {
+          select: {
+            id: true,
+            name: true,
+            slug: true
+          }
+        }
+      }
+    }) : null;
+    const user = {
+      ...result,
+      workspaceRole: member?.role || null,
+      activeWorkspace: member?.organization || null
+    };
+    return { user, isAuthenticated: true };
+  } catch (error) {
+    console.error("Error fetching initial user data:", error);
+    return { user: null, isAuthenticated: false };
+  }
+}
+
+// src/utils/workspace-select.ts
+var workspaceSelect = {
+  id: true,
+  name: true,
+  slug: true,
+  logo: true,
+  metadata: true,
+  createdAt: true,
+  members: {
+    select: {
+      id: true,
+      organizationId: true,
+      userId: true,
+      role: true,
+      createdAt: true,
+      user: {
+        select: {
+          id: true,
+          name: true,
+          email: true,
+          image: true
+        }
+      }
+    }
+  },
+  invitations: {
+    select: {
+      id: true,
+      organizationId: true,
+      inviterId: true,
+      email: true,
+      role: true,
+      status: true,
+      expiresAt: true
+    }
+  },
+  subscription: {
+    select: {
+      id: true,
+      userId: true,
+      workspaceId: true,
+      subscriptionId: true,
+      externalId: true,
+      provider: true,
+      status: true,
+      plan: true,
+      currentPeriodStart: true,
+      currentPeriodEnd: true,
+      cancelAtPeriodEnd: true,
+      canceledAt: true,
+      isLifetime: true
+    }
+  }
+};
+
+// src/queries/workspace.ts
+async function getWorkspacebySlug(db, session, slug, customSelect) {
+  if (!session || !session.user) {
+    return { error: true, message: "User not authenticated" };
+  }
+  try {
+    const result = await db.organization.findUnique({
+      where: { slug },
+      select: customSelect || workspaceSelect
+    });
+    if (!result) {
+      return { error: true, message: "Workspace not found" };
+    }
+    const isUserMember = result.members.some((member) => member.userId === session.user.id);
+    if (!isUserMember) {
+      return { error: true, message: "User is not a member of the workspace" };
+    }
+    const currentUserMember = result.members.find(
+      (member) => member.userId === session.user.id
+    );
+    const currentUserRole = currentUserMember?.role || null;
+    const workspace = {
+      ...result,
+      currentUserRole
+    };
+    return workspace;
+  } catch (error) {
+    console.error("Error fetching workspace data:", error);
+    return { error: true, message: "Error fetching workspace data." };
+  }
+}
+async function getWorkspaceList(db, session, customSelect) {
+  if (!session || !session.user) {
+    return { error: true, message: "User not authenticated" };
+  }
+  try {
+    const result = await db.organization.findMany({
+      where: {
+        members: {
+          some: {
+            userId: session.user.id
+          }
+        }
+      },
+      select: customSelect || workspaceSelect,
+      orderBy: {
+        createdAt: "desc"
+      }
+    });
+    const workspaces = result.map((ws) => {
+      const currentUserMember = ws.members.find((member) => member.userId === session.user.id);
+      return {
+        ...ws,
+        currentUserRole: currentUserMember?.role || null
+      };
+    });
+    return workspaces;
+  } catch (error) {
+    console.error("Error fetching workspace list:", error);
+    return { error: true, message: "Error fetching workspace list." };
+  }
+}
+async function getInitialWorkspaceData(db, session, customSelect) {
+  if (!session?.user || !session.session?.activeOrganizationId) {
+    return null;
+  }
+  try {
+    const workspace = await db.organization.findUnique({
+      where: { id: session.session.activeOrganizationId },
+      select: customSelect || workspaceSelect
+    });
+    if (!workspace) {
+      return null;
+    }
+    const currentUserMember = workspace.members.find(
+      (member) => member.userId === session.user.id
+    );
+    return {
+      ...workspace,
+      currentUserRole: currentUserMember?.role || null
+    };
+  } catch (error) {
+    console.error("Error fetching initial workspace data:", error);
+    return null;
+  }
+}
+async function getLastActiveWorkspace(db, userId, slug) {
+  if (slug) {
+    const workspace = await db.organization.findFirst({
+      where: {
+        slug,
+        members: {
+          some: {
+            userId
+          }
+        }
+      },
+      select: { slug: true, id: true }
+    });
+    if (workspace) {
+      return {
+        slug: workspace.slug,
+        id: workspace.id
+      };
+    }
+  }
+  const ownerWorkspace = await db.organization.findFirst({
+    where: {
+      members: {
+        some: {
+          userId,
+          role: "owner"
+        }
+      }
+    },
+    select: { slug: true, id: true }
+  });
+  if (ownerWorkspace) {
+    return {
+      slug: ownerWorkspace.slug,
+      id: ownerWorkspace.id
+    };
+  }
+  const memberWorkspace = await db.organization.findFirst({
+    where: {
+      members: {
+        some: {
+          userId
+        }
+      }
+    },
+    select: { slug: true, id: true }
+  });
+  if (memberWorkspace) {
+    return {
+      slug: memberWorkspace.slug,
+      id: memberWorkspace.id
+    };
+  }
+}
+async function validateWorkspaceAccess(db, session, slug) {
+  if (!session?.user) {
+    return false;
+  }
+  const workspace = await db.organization.findFirst({
+    where: {
+      slug,
+      members: { some: { userId: session.user.id } }
+    },
+    select: { id: true }
+  });
+  return Boolean(workspace);
+}
+export {
+  createEmailLog,
+  createId,
+  createIdCustom,
+  getInitialUserData,
+  getInitialWorkspaceData,
+  getLastActiveWorkspace,
+  getUser,
+  getWorkspaceList,
+  getWorkspacebySlug,
+  updateUser,
+  updateUserData,
+  userSelect,
+  validateWorkspaceAccess,
+  workspaceSelect
+};

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "@pelatform/starter.db",
+  "version": "0.1.0",
+  "description": "A part of SaaS starter kit for Pelatform applications.",
+  "author": "Pelatform",
+  "license": "MIT",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "sideEffects": false,
+  "exports": {
+    "types": "./dist/index.d.ts",
+    "default": "./dist/index.js"
+  },
+  "scripts": {
+    "clean": "rimraf dist",
+    "clean:all": "rimraf .turbo dist node_modules",
+    "dev": "tsup --watch",
+    "build": "tsup",
+    "types:check": "tsc --noEmit"
+  },
+  "files": [
+    "dist"
+  ],
+  "keywords": [
+    "pelatform",
+    "starter kit",
+    "components",
+    "utilities",
+    "database"
+  ],
+  "dependencies": {
+    "base-x": "^5.0.1"
+  },
+  "devDependencies": {
+    "@pelatform/tsconfig": "^0.1.4",
+    "tsup": "^8.5.1"
+  },
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/",
+    "access": "public"
+  },
+  "lint-staged": {
+    "*.{js,jsx,ts,tsx,cjs,mjs,cts,mts}": "biome check --write --no-errors-on-unmatched",
+    "*.{md,yml,yaml}": "prettier --write",
+    "*.{json,jsonc,html}": "biome format --write --no-errors-on-unmatched"
+  }
+}