@goscribe/server 1.3.3 → 1.5.0

package/dist/repositories/user.repository.js

@@ -0,0 +1,37 @@
+import { BaseRepository } from './base.repository.js';
+export class UserRepository extends BaseRepository {
+    constructor(db) {
+        super(db);
+    }
+    findById(id, args) {
+        return this.db.user.findUnique({
+            ...args,
+            where: { id },
+        });
+    }
+    findByEmail(email, args) {
+        return this.db.user.findUnique({
+            ...args,
+            where: { email },
+        });
+    }
+    create(data) {
+        return this.db.user.create({ data });
+    }
+    update(id, data) {
+        return this.db.user.update({
+            where: { id },
+            data,
+        });
+    }
+    /**
+     * Soft-delete marker: set `deletedAt`. Hard-delete happens in
+     * `scripts/purge-deleted-users.ts`.
+     */
+    softDelete(id) {
+        return this.db.user.update({
+            where: { id },
+            data: { deletedAt: new Date() },
+        });
+    }
+}

package/dist/repositories/workspace-member.repository.d.ts

@@ -0,0 +1,31 @@
+import type { Prisma, PrismaClient } from '@prisma/client';
+import { BaseRepository } from './base.repository.js';
+export declare class WorkspaceMemberRepository extends BaseRepository {
+    constructor(db: PrismaClient);
+    findByWorkspaceAndUser(workspaceId: string, userId: string): Prisma.Prisma__WorkspaceMemberClient<{
+        id: string;
+        updatedAt: Date;
+        workspaceId: string;
+        userId: string;
+        role: string;
+        joinedAt: Date;
+    } | null, null, import("@prisma/client/runtime/library").DefaultArgs, Prisma.PrismaClientOptions>;
+    listByWorkspace(workspaceId: string, include?: Prisma.WorkspaceMemberInclude): Prisma.PrismaPromise<{
+        id: string;
+        updatedAt: Date;
+        workspaceId: string;
+        userId: string;
+        role: string;
+        joinedAt: Date;
+    }[]>;
+    create(data: Prisma.WorkspaceMemberCreateInput): Prisma.Prisma__WorkspaceMemberClient<{
+        id: string;
+        updatedAt: Date;
+        workspaceId: string;
+        userId: string;
+        role: string;
+        joinedAt: Date;
+    }, never, import("@prisma/client/runtime/library").DefaultArgs, Prisma.PrismaClientOptions>;
+    delete(workspaceId: string, userId: string): Prisma.PrismaPromise<Prisma.BatchPayload>;
+    updateRole(workspaceId: string, userId: string, role: string): Prisma.PrismaPromise<Prisma.BatchPayload>;
+}

package/dist/repositories/workspace-member.repository.js

@@ -0,0 +1,31 @@
+import { BaseRepository } from './base.repository.js';
+export class WorkspaceMemberRepository extends BaseRepository {
+    constructor(db) {
+        super(db);
+    }
+    findByWorkspaceAndUser(workspaceId, userId) {
+        return this.db.workspaceMember.findFirst({
+            where: { workspaceId, userId },
+        });
+    }
+    listByWorkspace(workspaceId, include) {
+        return this.db.workspaceMember.findMany({
+            where: { workspaceId },
+            include,
+        });
+    }
+    create(data) {
+        return this.db.workspaceMember.create({ data });
+    }
+    delete(workspaceId, userId) {
+        return this.db.workspaceMember.deleteMany({
+            where: { workspaceId, userId },
+        });
+    }
+    updateRole(workspaceId, userId, role) {
+        return this.db.workspaceMember.updateMany({
+            where: { workspaceId, userId },
+            data: { role },
+        });
+    }
+}

package/dist/repositories/workspace.repository.d.ts

@@ -0,0 +1,97 @@
+import type { Prisma, PrismaClient } from '@prisma/client';
+import { BaseRepository } from './base.repository.js';
+/**
+ * Prisma `where` fragment: workspace is accessible to the user if they are
+ * the owner OR a workspace member. Prefer this over ad-hoc `{ ownerId }`
+ * checks to keep collaborative-workspace behavior consistent.
+ *
+ * NOTE: This is the canonical replacement for the former
+ * `lib/workspace-access.ts#workspaceAccessFilter`. Call sites that previously
+ * spread the filter into a larger `where` can still do so.
+ */
+export declare function workspaceAccessWhere(userId: string): Prisma.WorkspaceWhereInput;
+/**
+ * Prisma `where` fragment for owner-only access. Some legacy call sites
+ * (e.g. `workspace.list`, `workspace.create`, some `workspace.getTree`
+ * paths) intentionally use owner-only semantics. Keep a separate helper so
+ * the difference is explicit at the call site.
+ */
+export declare function workspaceOwnerWhere(userId: string): Prisma.WorkspaceWhereInput;
+export declare class WorkspaceRepository extends BaseRepository {
+    constructor(db: PrismaClient);
+    /**
+     * Fetch a workspace if the user is the owner OR a member.
+     * Preserves the member-inclusive behavior used by most read paths.
+     */
+    findByIdAccessible(workspaceId: string, userId: string): Prisma.Prisma__WorkspaceClient<{
+        id: string;
+        createdAt: Date;
+        updatedAt: Date;
+        title: string;
+        description: string | null;
+        ownerId: string;
+        color: string;
+        markerColor: string | null;
+        icon: string;
+        folderId: string | null;
+        fileBeingAnalyzed: boolean;
+        analysisProgress: Prisma.JsonValue | null;
+        needsAnalysis: boolean;
+    } | null, null, import("@prisma/client/runtime/library").DefaultArgs, Prisma.PrismaClientOptions>;
+    /**
+     * Fetch a workspace only if the user owns it. Preserves the owner-only
+     * semantics used today by `workspace.list`, `workspace.create`, and some
+     * management paths.
+     */
+    findByIdOwned(workspaceId: string, userId: string): Prisma.Prisma__WorkspaceClient<{
+        id: string;
+        createdAt: Date;
+        updatedAt: Date;
+        title: string;
+        description: string | null;
+        ownerId: string;
+        color: string;
+        markerColor: string | null;
+        icon: string;
+        folderId: string | null;
+        fileBeingAnalyzed: boolean;
+        analysisProgress: Prisma.JsonValue | null;
+        needsAnalysis: boolean;
+    } | null, null, import("@prisma/client/runtime/library").DefaultArgs, Prisma.PrismaClientOptions>;
+    listAccessible(userId: string, args?: Omit<Prisma.WorkspaceFindManyArgs, 'where'>): Prisma.PrismaPromise<{
+        id: string;
+        createdAt: Date;
+        updatedAt: Date;
+        title: string;
+        description: string | null;
+        ownerId: string;
+        color: string;
+        markerColor: string | null;
+        icon: string;
+        folderId: string | null;
+        fileBeingAnalyzed: boolean;
+        analysisProgress: Prisma.JsonValue | null;
+        needsAnalysis: boolean;
+    }[]>;
+    listOwned(userId: string, args?: Omit<Prisma.WorkspaceFindManyArgs, 'where'>): Prisma.PrismaPromise<{
+        id: string;
+        createdAt: Date;
+        updatedAt: Date;
+        title: string;
+        description: string | null;
+        ownerId: string;
+        color: string;
+        markerColor: string | null;
+        icon: string;
+        folderId: string | null;
+        fileBeingAnalyzed: boolean;
+        analysisProgress: Prisma.JsonValue | null;
+        needsAnalysis: boolean;
+    }[]>;
+    /**
+     * Escape hatch for services that need to splice the access clause into a
+     * larger query (e.g. `artifact.findFirst({ where: { ..., workspace: ... } })`).
+     */
+    static accessibleWhere(userId: string): Prisma.WorkspaceWhereInput;
+    static ownedWhere(userId: string): Prisma.WorkspaceWhereInput;
+}

package/dist/repositories/workspace.repository.js

@@ -0,0 +1,79 @@
+import { BaseRepository } from './base.repository.js';
+/**
+ * Prisma `where` fragment: workspace is accessible to the user if they are
+ * the owner OR a workspace member. Prefer this over ad-hoc `{ ownerId }`
+ * checks to keep collaborative-workspace behavior consistent.
+ *
+ * NOTE: This is the canonical replacement for the former
+ * `lib/workspace-access.ts#workspaceAccessFilter`. Call sites that previously
+ * spread the filter into a larger `where` can still do so.
+ */
+export function workspaceAccessWhere(userId) {
+    return {
+        OR: [
+            { ownerId: userId },
+            { members: { some: { userId } } },
+        ],
+    };
+}
+/**
+ * Prisma `where` fragment for owner-only access. Some legacy call sites
+ * (e.g. `workspace.list`, `workspace.create`, some `workspace.getTree`
+ * paths) intentionally use owner-only semantics. Keep a separate helper so
+ * the difference is explicit at the call site.
+ */
+export function workspaceOwnerWhere(userId) {
+    return { ownerId: userId };
+}
+export class WorkspaceRepository extends BaseRepository {
+    constructor(db) {
+        super(db);
+    }
+    /**
+     * Fetch a workspace if the user is the owner OR a member.
+     * Preserves the member-inclusive behavior used by most read paths.
+     */
+    findByIdAccessible(workspaceId, userId) {
+        return this.db.workspace.findFirst({
+            where: {
+                id: workspaceId,
+                ...workspaceAccessWhere(userId),
+            },
+        });
+    }
+    /**
+     * Fetch a workspace only if the user owns it. Preserves the owner-only
+     * semantics used today by `workspace.list`, `workspace.create`, and some
+     * management paths.
+     */
+    findByIdOwned(workspaceId, userId) {
+        return this.db.workspace.findFirst({
+            where: {
+                id: workspaceId,
+                ownerId: userId,
+            },
+        });
+    }
+    listAccessible(userId, args) {
+        return this.db.workspace.findMany({
+            ...args,
+            where: workspaceAccessWhere(userId),
+        });
+    }
+    listOwned(userId, args) {
+        return this.db.workspace.findMany({
+            ...args,
+            where: { ownerId: userId },
+        });
+    }
+    /**
+     * Escape hatch for services that need to splice the access clause into a
+     * larger query (e.g. `artifact.findFirst({ where: { ..., workspace: ... } })`).
+     */
+    static accessibleWhere(userId) {
+        return workspaceAccessWhere(userId);
+    }
+    static ownedWhere(userId) {
+        return workspaceOwnerWhere(userId);
+    }
+}