@goscribe/server 1.0.1 → 1.0.3

package/dist/context.d.ts

@@ -1,6 +1,6 @@
 import type { CreateExpressContextOptions } from "@trpc/server/adapters/express";
 export declare function createContext({ req, res }: CreateExpressContextOptions): Promise<{
-    db: import("src/generated/prisma").PrismaClient<import("src/generated/prisma").Prisma.PrismaClientOptions, never, import("src/generated/prisma/runtime/library").DefaultArgs>;
+    db: import(".prisma/client").PrismaClient<import(".prisma/client").Prisma.PrismaClientOptions, never, import("@prisma/client/runtime/library").DefaultArgs>;
     session: any;
     req: import("express").Request<import("express-serve-static-core").ParamsDictionary, any, any, import("qs").ParsedQs, Record<string, any>>;
     res: import("express").Response<any, Record<string, any>>;

package/dist/lib/file.d.ts

@@ -0,0 +1 @@
+//# sourceMappingURL=file.d.ts.map

package/dist/lib/file.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"file.d.ts","sourceRoot":"","sources":["../../src/lib/file.ts"],"names":[],"mappings":""}

package/dist/lib/file.js

@@ -0,0 +1 @@
+"use strict";

package/dist/lib/prisma.d.ts

@@ -1,3 +1,3 @@
-import { PrismaClient } from "../generated/prisma";
-export declare const prisma: PrismaClient<import("../generated/prisma").Prisma.PrismaClientOptions, never, import("src/generated/prisma/runtime/library").DefaultArgs>;
+import { PrismaClient } from "@prisma/client";
+export declare const prisma: PrismaClient<import(".prisma/client").Prisma.PrismaClientOptions, never, import("@prisma/client/runtime/library").DefaultArgs>;
 //# sourceMappingURL=prisma.d.ts.map

package/dist/lib/prisma.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"prisma.d.ts","sourceRoot":"","sources":["../../src/lib/prisma.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAInD,eAAO,MAAM,MAAM,2IAIf,CAAC"}
+{"version":3,"file":"prisma.d.ts","sourceRoot":"","sources":["../../src/lib/prisma.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAI9C,eAAO,MAAM,MAAM,gIAIf,CAAC"}

package/dist/lib/prisma.js

@@ -1,10 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.prisma = void 0;
-const prisma_1 = require("../generated/prisma");
+const client_1 = require("@prisma/client");
 const globalForPrisma = globalThis;
 exports.prisma = globalForPrisma.prisma ??
-    new prisma_1.PrismaClient({
+    new client_1.PrismaClient({
     // log: ["query"], // enable if you want
     });
 if (process.env.NODE_ENV !== "production")

package/dist/lib/storage.d.ts

@@ -0,0 +1,4 @@
+import { Storage } from "@google-cloud/storage";
+export declare const storage: Storage;
+export declare const bucket: import("@google-cloud/storage").Bucket;
+//# sourceMappingURL=storage.d.ts.map

package/dist/lib/storage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"storage.d.ts","sourceRoot":"","sources":["../../src/lib/storage.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,OAAO,EAAE,MAAM,uBAAuB,CAAC;AAEhD,eAAO,MAAM,OAAO,SAMlB,CAAC;AAEH,eAAO,MAAM,MAAM,wCAA0C,CAAC"}

package/dist/lib/storage.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bucket = exports.storage = void 0;
+// src/server/lib/gcs.ts
+const storage_1 = require("@google-cloud/storage");
+exports.storage = new storage_1.Storage({
+    projectId: process.env.GCP_PROJECT_ID,
+    credentials: {
+        client_email: process.env.GCP_CLIENT_EMAIL,
+        private_key: process.env.GCP_PRIVATE_KEY?.replace(/\\n/g, "\n"),
+    },
+});
+exports.bucket = exports.storage.bucket(process.env.GCP_BUCKET);

package/dist/routers/_app.d.ts

@@ -1,7 +1,7 @@
 import { inferRouterInputs, inferRouterOutputs } from '@trpc/server';
 export declare const appRouter: import("@trpc/server").TRPCBuiltRouter<{
     ctx: {
-        db: import("src/generated/prisma").PrismaClient<import("src/generated/prisma").Prisma.PrismaClientOptions, never, import("src/generated/prisma/runtime/library").DefaultArgs>;
+        db: import(".prisma/client").PrismaClient<import(".prisma/client").Prisma.PrismaClientOptions, never, import("@prisma/client/runtime/library").DefaultArgs>;
         session: any;
         req: import("express").Request<import("express-serve-static-core").ParamsDictionary, any, any, import("qs").ParsedQs, Record<string, any>>;
         res: import("express").Response<any, Record<string, any>>;
@@ -12,7 +12,7 @@ export declare const appRouter: import("@trpc/server").TRPCBuiltRouter<{
 }, import("@trpc/server").TRPCDecorateCreateRouterOptions<{
     auth: import("@trpc/server").TRPCBuiltRouter<{
         ctx: {
-            db: import("src/generated/prisma").PrismaClient<import("src/generated/prisma").Prisma.PrismaClientOptions, never, import("src/generated/prisma/runtime/library").DefaultArgs>;
+            db: import(".prisma/client").PrismaClient<import(".prisma/client").Prisma.PrismaClientOptions, never, import("@prisma/client/runtime/library").DefaultArgs>;
             session: any;
             req: import("express").Request<import("express-serve-static-core").ParamsDictionary, any, any, import("qs").ParsedQs, Record<string, any>>;
             res: import("express").Response<any, Record<string, any>>;
@@ -37,7 +37,7 @@ export declare const appRouter: import("@trpc/server").TRPCBuiltRouter<{
     }>>;
     workspace: import("@trpc/server").TRPCBuiltRouter<{
         ctx: {
-            db: import("src/generated/prisma").PrismaClient<import("src/generated/prisma").Prisma.PrismaClientOptions, never, import("src/generated/prisma/runtime/library").DefaultArgs>;
+            db: import(".prisma/client").PrismaClient<import(".prisma/client").Prisma.PrismaClientOptions, never, import("@prisma/client/runtime/library").DefaultArgs>;
             session: any;
             req: import("express").Request<import("express-serve-static-core").ParamsDictionary, any, any, import("qs").ParsedQs, Record<string, any>>;
             res: import("express").Response<any, Record<string, any>>;
@@ -48,47 +48,93 @@ export declare const appRouter: import("@trpc/server").TRPCBuiltRouter<{
     }, import("@trpc/server").TRPCDecorateCreateRouterOptions<{
         list: import("@trpc/server").TRPCQueryProcedure<{
             input: void;
-            output: void;
+            output: {
+                id: string;
+                createdAt: Date;
+                updatedAt: Date;
+                ownerId: string;
+                title: string;
+                description: string | null;
+                folderId: string | null;
+            }[];
             meta: object;
         }>;
         create: import("@trpc/server").TRPCMutationProcedure<{
-            input: Record<string, never>;
-            output: void;
+            input: {
+                name: string;
+                description?: string | undefined;
+            };
+            output: {
+                id: string;
+                createdAt: Date;
+                updatedAt: Date;
+                ownerId: string;
+                title: string;
+                description: string | null;
+                folderId: string | null;
+            };
             meta: object;
         }>;
         get: import("@trpc/server").TRPCQueryProcedure<{
             input: {
                 id: string;
             };
-            output: void;
+            output: {
+                id: string;
+                createdAt: Date;
+                updatedAt: Date;
+                ownerId: string;
+                title: string;
+                description: string | null;
+                folderId: string | null;
+            } | null;
             meta: object;
         }>;
         update: import("@trpc/server").TRPCMutationProcedure<{
             input: {
                 id: string;
+                name?: string | undefined;
+                description?: string | undefined;
+            };
+            output: {
+                id: string;
+                createdAt: Date;
+                updatedAt: Date;
+                ownerId: string;
+                title: string;
+                description: string | null;
+                folderId: string | null;
             };
-            output: void;
             meta: object;
         }>;
         delete: import("@trpc/server").TRPCMutationProcedure<{
             input: {
                 id: string;
             };
-            output: void;
+            output: boolean;
             meta: object;
         }>;
-        upload: import("@trpc/server").TRPCMutationProcedure<{
+        uploadFiles: import("@trpc/server").TRPCMutationProcedure<{
             input: {
-                file: string;
+                id: string;
+                files: {
+                    filename: string;
+                    contentType: string;
+                    size: number;
+                }[];
             };
-            output: void;
+            output: {
+                fileId: string;
+                uploadUrl: string;
+            }[];
             meta: object;
         }>;
-        deleteFile: import("@trpc/server").TRPCMutationProcedure<{
+        deleteFiles: import("@trpc/server").TRPCMutationProcedure<{
             input: {
-                fileId: string;
+                fileId: string[];
+                id: string;
             };
-            output: void;
+            output: import(".prisma/client").Prisma.BatchPayload;
             meta: object;
         }>;
     }>>;

package/dist/routers/_app.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"_app.d.ts","sourceRoot":"","sources":["../../src/routers/_app.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,kBAAkB,EAAE,MAAM,cAAc,CAAC;AAKrE,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAGpB,CAAC;AAGH,MAAM,MAAM,SAAS,GAAG,OAAO,SAAS,CAAC;AACzC,MAAM,MAAM,YAAY,GAAG,iBAAiB,CAAC,SAAS,CAAC,CAAC;AACxD,MAAM,MAAM,aAAa,GAAG,kBAAkB,CAAC,SAAS,CAAC,CAAC"}
+{"version":3,"file":"_app.d.ts","sourceRoot":"","sources":["../../src/routers/_app.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,kBAAkB,EAAE,MAAM,cAAc,CAAC;AAKrE,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAGpB,CAAC;AAGH,MAAM,MAAM,SAAS,GAAG,OAAO,SAAS,CAAC;AACzC,MAAM,MAAM,YAAY,GAAG,iBAAiB,CAAC,SAAS,CAAC,CAAC;AACxD,MAAM,MAAM,aAAa,GAAG,kBAAkB,CAAC,SAAS,CAAC,CAAC"}

package/dist/routers/auth.d.ts

@@ -1,6 +1,6 @@
 export declare const auth: import("@trpc/server").TRPCBuiltRouter<{
     ctx: {
-        db: import("src/generated/prisma").PrismaClient<import("src/generated/prisma").Prisma.PrismaClientOptions, never, import("src/generated/prisma/runtime/library").DefaultArgs>;
+        db: import(".prisma/client").PrismaClient<import(".prisma/client").Prisma.PrismaClientOptions, never, import("@prisma/client/runtime/library").DefaultArgs>;
         session: any;
         req: import("express").Request<import("express-serve-static-core").ParamsDictionary, any, any, import("qs").ParsedQs, Record<string, any>>;
         res: import("express").Response<any, Record<string, any>>;

package/dist/routers/workspace.d.ts

@@ -1,6 +1,6 @@
 export declare const workspace: import("@trpc/server").TRPCBuiltRouter<{
     ctx: {
-        db: import("src/generated/prisma").PrismaClient<import("src/generated/prisma").Prisma.PrismaClientOptions, never, import("src/generated/prisma/runtime/library").DefaultArgs>;
+        db: import(".prisma/client").PrismaClient<import(".prisma/client").Prisma.PrismaClientOptions, never, import("@prisma/client/runtime/library").DefaultArgs>;
         session: any;
         req: import("express").Request<import("express-serve-static-core").ParamsDictionary, any, any, import("qs").ParsedQs, Record<string, any>>;
         res: import("express").Response<any, Record<string, any>>;
@@ -11,47 +11,93 @@ export declare const workspace: import("@trpc/server").TRPCBuiltRouter<{
 }, import("@trpc/server").TRPCDecorateCreateRouterOptions<{
     list: import("@trpc/server").TRPCQueryProcedure<{
         input: void;
-        output: void;
+        output: {
+            id: string;
+            createdAt: Date;
+            updatedAt: Date;
+            ownerId: string;
+            title: string;
+            description: string | null;
+            folderId: string | null;
+        }[];
         meta: object;
     }>;
     create: import("@trpc/server").TRPCMutationProcedure<{
-        input: Record<string, never>;
-        output: void;
+        input: {
+            name: string;
+            description?: string | undefined;
+        };
+        output: {
+            id: string;
+            createdAt: Date;
+            updatedAt: Date;
+            ownerId: string;
+            title: string;
+            description: string | null;
+            folderId: string | null;
+        };
         meta: object;
     }>;
     get: import("@trpc/server").TRPCQueryProcedure<{
         input: {
             id: string;
         };
-        output: void;
+        output: {
+            id: string;
+            createdAt: Date;
+            updatedAt: Date;
+            ownerId: string;
+            title: string;
+            description: string | null;
+            folderId: string | null;
+        } | null;
         meta: object;
     }>;
     update: import("@trpc/server").TRPCMutationProcedure<{
         input: {
             id: string;
+            name?: string | undefined;
+            description?: string | undefined;
+        };
+        output: {
+            id: string;
+            createdAt: Date;
+            updatedAt: Date;
+            ownerId: string;
+            title: string;
+            description: string | null;
+            folderId: string | null;
         };
-        output: void;
         meta: object;
     }>;
     delete: import("@trpc/server").TRPCMutationProcedure<{
         input: {
             id: string;
         };
-        output: void;
+        output: boolean;
         meta: object;
     }>;
-    upload: import("@trpc/server").TRPCMutationProcedure<{
+    uploadFiles: import("@trpc/server").TRPCMutationProcedure<{
         input: {
-            file: string;
+            id: string;
+            files: {
+                filename: string;
+                contentType: string;
+                size: number;
+            }[];
         };
-        output: void;
+        output: {
+            fileId: string;
+            uploadUrl: string;
+        }[];
         meta: object;
     }>;
-    deleteFile: import("@trpc/server").TRPCMutationProcedure<{
+    deleteFiles: import("@trpc/server").TRPCMutationProcedure<{
         input: {
-            fileId: string;
+            fileId: string[];
+            id: string;
         };
-        output: void;
+        output: import(".prisma/client").Prisma.BatchPayload;
         meta: object;
     }>;
 }>>;

package/dist/routers/workspace.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"workspace.d.ts","sourceRoot":"","sources":["../../src/routers/workspace.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+CpB,CAAC"}
+{"version":3,"file":"workspace.d.ts","sourceRoot":"","sources":["../../src/routers/workspace.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuJpB,CAAC"}

package/dist/routers/workspace.js

@@ -3,43 +3,145 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.workspace = void 0;
 const zod_1 = require("zod");
 const trpc_1 = require("../trpc");
+const storage_1 = require("src/lib/storage");
 exports.workspace = (0, trpc_1.router)({
     // Mutation with Zod input
     list: trpc_1.publicProcedure
         .query(async ({ ctx, input }) => {
+        const workspaces = await ctx.db.workspace.findMany({
+            where: {
+                ownerId: ctx.session?.user.id,
+            },
+        });
+        return workspaces;
     }),
     create: trpc_1.publicProcedure
-        .input(zod_1.z.object({}))
-        .mutation(({ input }) => {
+        .input(zod_1.z.object({
+        name: zod_1.z.string().min(1).max(100),
+        description: zod_1.z.string().max(500).optional(),
+    }))
+        .mutation(({ ctx, input }) => {
+        return ctx.db.workspace.create({
+            data: {
+                title: input.name,
+                description: input.description,
+                ownerId: ctx.session?.user.id,
+            },
+        });
     }),
     get: trpc_1.publicProcedure
         .input(zod_1.z.object({
         id: zod_1.z.string().uuid(),
     }))
-        .query(({ input }) => {
+        .query(({ ctx, input }) => {
+        return ctx.db.workspace.findUnique({
+            where: {
+                id: input.id,
+            },
+        });
     }),
     update: trpc_1.publicProcedure
         .input(zod_1.z.object({
         id: zod_1.z.string().uuid(),
+        name: zod_1.z.string().min(1).max(100).optional(),
+        description: zod_1.z.string().max(500).optional(),
     }))
-        .mutation(({ input }) => {
+        .mutation(({ ctx, input }) => {
+        return ctx.db.workspace.update({
+            where: {
+                id: input.id,
+            },
+            data: {
+                title: input.name,
+                description: input.description,
+            },
+        });
     }),
     delete: trpc_1.publicProcedure
         .input(zod_1.z.object({
         id: zod_1.z.string().uuid(),
     }))
-        .mutation(({ input }) => {
+        .mutation(({ ctx, input }) => {
+        ctx.db.workspace.delete({
+            where: {
+                id: input.id,
+            },
+        });
+        return true;
     }),
-    upload: trpc_1.publicProcedure
+    uploadFiles: trpc_1.publicProcedure
         .input(zod_1.z.object({
-        file: zod_1.z.string(),
+        id: zod_1.z.string().uuid(),
+        files: zod_1.z.array(zod_1.z.object({
+            filename: zod_1.z.string().min(1).max(255),
+            contentType: zod_1.z.string().min(1).max(100),
+            size: zod_1.z.number().min(1), // size in bytes
+        })),
     }))
-        .mutation(({ input }) => {
+        .mutation(async ({ ctx, input }) => {
+        const results = [];
+        for (const file of input.files) {
+            // 1. Insert into DB
+            const record = await ctx.db.fileAsset.create({
+                data: {
+                    userId: ctx.session.user.id,
+                    name: file.filename,
+                    mimeType: file.contentType,
+                    size: file.size,
+                    workspaceId: input.id,
+                },
+            });
+            // 2. Generate signed URL for direct upload
+            const [url] = await storage_1.bucket
+                .file(`${ctx.session.user.id}/${record.id}-${file.filename}`)
+                .getSignedUrl({
+                action: "write",
+                expires: Date.now() + 5 * 60 * 1000, // 5 min
+                contentType: file.contentType,
+            });
+            // 3. Update record with bucket info
+            await ctx.db.fileAsset.update({
+                where: { id: record.id },
+                data: {
+                    bucket: storage_1.bucket.name,
+                    objectKey: `${ctx.session.user.id}/${record.id}-${file.filename}`,
+                },
+            });
+            results.push({
+                fileId: record.id,
+                uploadUrl: url,
+            });
+        }
+        return results;
     }),
-    deleteFile: trpc_1.publicProcedure
+    deleteFiles: trpc_1.publicProcedure
         .input(zod_1.z.object({
-        fileId: zod_1.z.string().uuid(),
+        fileId: zod_1.z.array(zod_1.z.string().uuid()),
+        id: zod_1.z.string().uuid(),
     }))
-        .mutation(({ input }) => {
+        .mutation(({ ctx, input }) => {
+        const files = ctx.db.fileAsset.findMany({
+            where: {
+                id: { in: input.fileId },
+                workspaceId: input.id,
+            },
+        });
+        // Delete from GCS
+        files.then((fileRecords) => {
+            fileRecords.forEach((file) => {
+                if (file.bucket && file.objectKey) {
+                    const gcsFile = storage_1.bucket.file(file.objectKey);
+                    gcsFile.delete({ ignoreNotFound: true }).catch((err) => {
+                        console.error(`Error deleting file ${file.objectKey} from bucket ${file.bucket}:`, err);
+                    });
+                }
+            });
+        });
+        return ctx.db.fileAsset.deleteMany({
+            where: {
+                id: { in: input.fileId },
+                workspaceId: input.id,
+            },
+        });
     }),
 });

package/dist/server.js

@@ -50,7 +50,10 @@ async function main() {
     const app = (0, express_1.default)();
     // Middlewares
     app.use((0, helmet_1.default)());
-    app.use((0, cors_1.default)({ origin: true, credentials: true }));
+    app.use((0, cors_1.default)({
+        origin: "http://localhost:3000", // your Next.js dev URL
+        credentials: true, // allow cookies
+    }));
     app.use((0, morgan_1.default)('dev'));
     app.use((0, compression_1.default)());
     app.use(express_1.default.json());

package/dist/trpc.d.ts

@@ -1,6 +1,6 @@
 export declare const router: import("@trpc/server").TRPCRouterBuilder<{
     ctx: {
-        db: import("src/generated/prisma").PrismaClient<import("src/generated/prisma").Prisma.PrismaClientOptions, never, import("src/generated/prisma/runtime/library").DefaultArgs>;
+        db: import(".prisma/client").PrismaClient<import(".prisma/client").Prisma.PrismaClientOptions, never, import("@prisma/client/runtime/library").DefaultArgs>;
         session: any;
         req: import("express").Request<import("express-serve-static-core").ParamsDictionary, any, any, import("qs").ParsedQs, Record<string, any>>;
         res: import("express").Response<any, Record<string, any>>;
@@ -10,32 +10,32 @@ export declare const router: import("@trpc/server").TRPCRouterBuilder<{
     transformer: true;
 }>;
 export declare const middleware: <$ContextOverrides>(fn: import("@trpc/server").TRPCMiddlewareFunction<{
-    db: import("src/generated/prisma").PrismaClient<import("src/generated/prisma").Prisma.PrismaClientOptions, never, import("src/generated/prisma/runtime/library").DefaultArgs>;
+    db: import(".prisma/client").PrismaClient<import(".prisma/client").Prisma.PrismaClientOptions, never, import("@prisma/client/runtime/library").DefaultArgs>;
     session: any;
     req: import("express").Request<import("express-serve-static-core").ParamsDictionary, any, any, import("qs").ParsedQs, Record<string, any>>;
     res: import("express").Response<any, Record<string, any>>;
 }, object, object, $ContextOverrides, unknown>) => import("@trpc/server").TRPCMiddlewareBuilder<{
-    db: import("src/generated/prisma").PrismaClient<import("src/generated/prisma").Prisma.PrismaClientOptions, never, import("src/generated/prisma/runtime/library").DefaultArgs>;
+    db: import(".prisma/client").PrismaClient<import(".prisma/client").Prisma.PrismaClientOptions, never, import("@prisma/client/runtime/library").DefaultArgs>;
     session: any;
     req: import("express").Request<import("express-serve-static-core").ParamsDictionary, any, any, import("qs").ParsedQs, Record<string, any>>;
     res: import("express").Response<any, Record<string, any>>;
 }, object, $ContextOverrides, unknown>;
 export declare const publicProcedure: import("@trpc/server").TRPCProcedureBuilder<{
-    db: import("src/generated/prisma").PrismaClient<import("src/generated/prisma").Prisma.PrismaClientOptions, never, import("src/generated/prisma/runtime/library").DefaultArgs>;
+    db: import(".prisma/client").PrismaClient<import(".prisma/client").Prisma.PrismaClientOptions, never, import("@prisma/client/runtime/library").DefaultArgs>;
     session: any;
     req: import("express").Request<import("express-serve-static-core").ParamsDictionary, any, any, import("qs").ParsedQs, Record<string, any>>;
     res: import("express").Response<any, Record<string, any>>;
 }, object, object, import("@trpc/server").TRPCUnsetMarker, import("@trpc/server").TRPCUnsetMarker, import("@trpc/server").TRPCUnsetMarker, import("@trpc/server").TRPCUnsetMarker, false>;
 /** Exported authed procedure */
 export declare const authedProcedure: import("@trpc/server").TRPCProcedureBuilder<{
-    db: import("src/generated/prisma").PrismaClient<import("src/generated/prisma").Prisma.PrismaClientOptions, never, import("src/generated/prisma/runtime/library").DefaultArgs>;
+    db: import(".prisma/client").PrismaClient<import(".prisma/client").Prisma.PrismaClientOptions, never, import("@prisma/client/runtime/library").DefaultArgs>;
     session: any;
     req: import("express").Request<import("express-serve-static-core").ParamsDictionary, any, any, import("qs").ParsedQs, Record<string, any>>;
     res: import("express").Response<any, Record<string, any>>;
 }, object, {
     req: import("express").Request<import("express-serve-static-core").ParamsDictionary, any, any, import("qs").ParsedQs, Record<string, any>>;
     res: import("express").Response<any, Record<string, any>>;
-    db: import("src/generated/prisma").PrismaClient<import("src/generated/prisma").Prisma.PrismaClientOptions, never, import("src/generated/prisma/runtime/library").DefaultArgs>;
+    db: import(".prisma/client").PrismaClient<import(".prisma/client").Prisma.PrismaClientOptions, never, import("@prisma/client/runtime/library").DefaultArgs>;
     session: any;
 }, import("@trpc/server").TRPCUnsetMarker, import("@trpc/server").TRPCUnsetMarker, import("@trpc/server").TRPCUnsetMarker, import("@trpc/server").TRPCUnsetMarker, false>;
 //# sourceMappingURL=trpc.d.ts.map

package/package.json

@@ -1,9 +1,10 @@
 {
   "name": "@goscribe/server",
-  "version": "1.0.1",
+  "version": "1.0.3",
   "description": "",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
+  "type": "module",
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
@@ -12,14 +13,15 @@
   },
   "scripts": {
     "dev": "ts-node-dev --respawn --transpile-only src/server.ts",
-    "build": "tsc -p .",
-    "start": "node dist/server.js"
+    "build": "npx prisma generate && tsc -p .",
+    "start": "node --experimental-specifier-resolution=node dist/server.js"
   },
   "author": "",
   "license": "MIT",
   "dependencies": {
     "@auth/express": "^0.11.0",
     "@auth/prisma-adapter": "^2.10.0",
+    "@google-cloud/storage": "^7.17.0",
     "@prisma/client": "^6.14.0",
     "@trpc/server": "^11.5.0",
     "bcryptjs": "^3.0.2",
@@ -40,6 +42,9 @@
     "@types/node": "^24.3.0",
     "ts-node": "^10.9.2",
     "ts-node-dev": "^2.0.0",
-    "typescript": "^5.9.2"
+    "tsc-alias": "^1.8.16",
+    "tsc-esm-fix": "^3.1.2",
+    "typescript": "^5.9.2",
+    "typescript-transform-paths": "^3.5.5"
   }
 }

package/prisma/schema.prisma

@@ -1,7 +1,6 @@
 
 generator client {
   provider = "prisma-client-js"
-  output   = "../src/generated/prisma"
 }
 
 datasource db {
@@ -140,8 +139,8 @@ model FileAsset {
   name      String
   mimeType  String
   size      Int
-  bucket    String
-  objectKey String
+  bucket    String?
+  objectKey String?
   url       String?  // optional if serving via signed GET per-view
   checksum  String?  // optional server-side integrity
 

package/src/context.ts

@@ -1,6 +1,6 @@
 // src/server/trpc/context.ts
 import type { CreateExpressContextOptions } from "@trpc/server/adapters/express";
-import { prisma } from "./lib/prisma";
+import { prisma } from "./lib/prisma.js";
 
 export async function createContext({ req, res }: CreateExpressContextOptions) {
   const session = (req as any).auth ?? null;

package/src/index.ts

@@ -1,3 +1,3 @@
-export type { AppRouter } from "./routers/_app";
-export type { RouterInputs } from "./routers/_app";
-export type { RouterOutputs } from "./routers/_app";
+export type { AppRouter } from "./routers/_app.js";
+export type { RouterInputs } from "./routers/_app.js";
+export type { RouterOutputs } from "./routers/_app.js";

package/src/lib/auth.ts

@@ -1,7 +1,7 @@
 // src/server/auth.ts
 import { ExpressAuth } from "@auth/express";
 import { PrismaAdapter } from "@auth/prisma-adapter";
-import { prisma } from "../lib/prisma";
+import { prisma } from "../lib/prisma.js";
 import Google from "@auth/core/providers/google";
 import Credentials from "@auth/core/providers/credentials";
 

package/src/lib/prisma.ts

@@ -1,4 +1,4 @@
-import { PrismaClient } from "../generated/prisma";
+import { PrismaClient } from "@prisma/client";
 
 const globalForPrisma = globalThis as unknown as { prisma?: PrismaClient };
 

package/src/lib/storage.ts

@@ -0,0 +1,13 @@
+// src/server/lib/gcs.ts
+import { Storage } from "@google-cloud/storage";
+
+export const storage = new Storage({
+  projectId: process.env.GCP_PROJECT_ID,
+  credentials: {
+    client_email: process.env.GCP_CLIENT_EMAIL,
+    private_key: process.env.GCP_PRIVATE_KEY?.replace(/\\n/g, "\n"),
+  },
+});
+
+export const bucket = storage.bucket(process.env.GCP_BUCKET!);
+

package/src/routers/_app.ts

@@ -1,7 +1,7 @@
 import { inferRouterInputs, inferRouterOutputs } from '@trpc/server';
-import { router } from '../trpc';
-import { auth } from './auth';
-import { workspace } from './workspace';
+import { router } from '../trpc.js';
+import { auth } from './auth.js';
+import { workspace } from './workspace.js';
 
 export const appRouter = router({
   auth,

package/src/routers/auth.ts

@@ -1,5 +1,5 @@
 import { z } from 'zod';
-import { router, publicProcedure, authedProcedure } from '../trpc';
+import { router, publicProcedure, authedProcedure } from '../trpc.js';
 import bcrypt from 'bcryptjs';
 
 export const auth = router({

package/src/routers/workspace.ts

@@ -1,51 +1,157 @@
 import { z } from 'zod';
-import { router, publicProcedure, authedProcedure } from '../trpc';
+import { router, publicProcedure, authedProcedure } from '../trpc.js';
+import { bucket } from '../lib/storage.js';
+import { FileAsset } from '@prisma/client';
 
 export const workspace = router({
   // Mutation with Zod input
   list: publicProcedure
     .query(async ({ ctx, input }) => {
+      const workspaces = await ctx.db.workspace.findMany({
+        where: {
+          ownerId: ctx.session?.user.id,
+        },
+      });
+      return workspaces;
     }),
     
   create: publicProcedure
     .input(z.object({
-  
+        name: z.string().min(1).max(100),
+        description: z.string().max(500).optional(),
      }))
-    .mutation(({ input }) => {
-   
+    .mutation(({ ctx, input}) => {
+      return ctx.db.workspace.create({
+        data: {
+          title: input.name,
+          description: input.description,
+          ownerId: ctx.session?.user.id,
+        },
+      });
     }),
   get: publicProcedure
     .input(z.object({
         id: z.string().uuid(),
      }))
-    .query(({ input }) => {
+    .query(({ ctx, input }) => {
+      return ctx.db.workspace.findUnique({
+        where: {
+          id: input.id,
+        },
+      });
     }),
   update: publicProcedure
     .input(z.object({
         id: z.string().uuid(),
+        name: z.string().min(1).max(100).optional(),
+        description: z.string().max(500).optional(),
      }))
-    .mutation(({ input }) => {
-   
+    .mutation(({ ctx, input }) => {
+      return ctx.db.workspace.update({
+        where: {
+          id: input.id,
+        },
+        data: {
+          title: input.name,
+          description: input.description,
+        },
+      }); 
     }), 
     delete: publicProcedure
     .input(z.object({
         id: z.string().uuid(),
      }))
-    .mutation(({ input }) => {
-   
+    .mutation(({ ctx, input }) => {
+      ctx.db.workspace.delete({
+        where: {
+          id: input.id,
+        },
+      });
+      return true;
     }),
-    upload: publicProcedure
+    uploadFiles: publicProcedure
     .input(z.object({
-        file: z.string(),
+        id: z.string().uuid(),
+        files: z.array(
+          z.object({
+            filename: z.string().min(1).max(255),
+            contentType: z.string().min(1).max(100),
+            size: z.number().min(1), // size in bytes
+          })
+        ),
      }))
-    .mutation(({ input }) => {
-   
+    .mutation(async ({ ctx, input }) => {
+      const results = [];
+
+      for (const file of input.files) {
+        // 1. Insert into DB
+        const record = await ctx.db.fileAsset.create({
+          data: {
+            userId: ctx.session.user.id,
+            name: file.filename,
+            mimeType: file.contentType,
+            size: file.size,
+            workspaceId: input.id,   
+          },
+        });
+
+        // 2. Generate signed URL for direct upload
+        const [url] = await bucket
+          .file(`${ctx.session.user.id}/${record.id}-${file.filename}`)
+          .getSignedUrl({
+            action: "write",
+            expires: Date.now() + 5 * 60 * 1000, // 5 min
+            contentType: file.contentType,
+          });
+
+        // 3. Update record with bucket info
+        await ctx.db.fileAsset.update({
+          where: { id: record.id },
+          data: {
+            bucket: bucket.name,
+            objectKey: `${ctx.session.user.id}/${record.id}-${file.filename}`,
+          },
+        }); 
+
+        results.push({
+          fileId: record.id,
+          uploadUrl: url,
+        });
+      }
+
+      return results;
+
     }),
-    deleteFile: publicProcedure
+    deleteFiles: publicProcedure
     .input(z.object({
-        fileId: z.string().uuid(),
+        fileId: z.array(z.string().uuid()),
+        id: z.string().uuid(),
      }))
-    .mutation(({ input }) => {
-   
+    .mutation(({ ctx, input }) => {
+      const files = ctx.db.fileAsset.findMany({
+        where: {
+          id: { in: input.fileId },
+          workspaceId: input.id,
+        },
+      });
+
+      // Delete from GCS
+      files.then((fileRecords: FileAsset[]) => {
+        fileRecords.forEach((file: FileAsset) => {
+          if (file.bucket && file.objectKey) {
+        const gcsFile: import('@google-cloud/storage').File = bucket.file(file.objectKey);
+        gcsFile.delete({ ignoreNotFound: true }).catch((err: unknown) => {
+          console.error(`Error deleting file ${file.objectKey} from bucket ${file.bucket}:`, err);
+        });
+          }
+        });
+      });
+
+      return ctx.db.fileAsset.deleteMany({
+        where: {
+          id: { in: input.fileId },
+          workspaceId: input.id,
+        },
+      });
     }),
 });

package/src/server.ts

@@ -4,10 +4,10 @@ import helmet from 'helmet';
 import morgan from 'morgan';
 import compression from 'compression';
 import * as trpcExpress from '@trpc/server/adapters/express';
-import { authRouter } from './lib/auth';
+import { authRouter } from './lib/auth.js';
 
-import { appRouter } from './routers/_app';
-import { createContext } from './context';
+import { appRouter } from './routers/_app.js';
+import { createContext } from './context.js';
 
 const PORT = process.env.PORT ? Number(process.env.PORT) : 3001;
 
@@ -16,7 +16,11 @@ async function main() {
 
   // Middlewares
   app.use(helmet());
-  app.use(cors({ origin: true, credentials: true }));
+  app.use(cors({
+    origin: "http://localhost:3000", // your Next.js dev URL
+    credentials: true, // allow cookies
+  }));
+
   app.use(morgan('dev'));
   app.use(compression());
   app.use(express.json());

package/src/trpc.ts

@@ -1,6 +1,6 @@
 import { initTRPC, TRPCError } from "@trpc/server";
 import superjson from "superjson";
-import type { Context } from "./context";
+import type { Context } from "./context.js";
 
 const t = initTRPC.context<Context>().create({
   transformer: superjson,

package/tsconfig.json

@@ -1,17 +1,24 @@
 {
   "compilerOptions": {
     "target": "ES2020",
-    "module": "CommonJS",
-    "moduleResolution": "node",
+    "module": "ES2020",             // <-- this ensures ESM output
+    "moduleResolution": "bundler",
+    "plugins": [
+      { "transform": "typescript-transform-paths" },
+      { "transform": "typescript-transform-paths", "afterDeclarations": true }
+
+    ],
+    "baseUrl": "./",
+    "declaration": true,
+    "declarationDir": "dist",       // optional, but keeps .d.ts in dist
+    "emitDeclarationOnly": false,   // unless you only want .d.ts
+    "noEmit": false,            // must not be true
+
     "esModuleInterop": true,
     "strict": true,
     "skipLibCheck": true,
-    "forceConsistentCasingInFileNames": true,
-    "outDir": "dist",
-    "baseUrl": ".", 
-    "declaration": true,
-    "declarationMap": true
+    "outDir": "dist"
   },
-  "include": ["src/**/*"],
-  "exclude": ["node_modules", "dist"]
-} 
+  "include": ["src"],
+  "exclude": ["node_modules", "dist" ]
+}