@goscribe/server 1.0.0 → 1.0.2

package/dist/context.d.ts

@@ -0,0 +1,9 @@
+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>;
+    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>>;
+}>;
+export type Context = Awaited<ReturnType<typeof createContext>>;
+//# sourceMappingURL=context.d.ts.map

package/dist/context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"context.d.ts","sourceRoot":"","sources":["../src/context.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,+BAA+B,CAAC;AAGjF,wBAAsB,aAAa,CAAC,EAAE,GAAG,EAAE,GAAG,EAAE,EAAE,2BAA2B;;;;;GAI5E;AAED,MAAM,MAAM,OAAO,GAAG,OAAO,CAAC,UAAU,CAAC,OAAO,aAAa,CAAC,CAAC,CAAC"}

package/dist/context.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createContext = createContext;
+const prisma_1 = require("./lib/prisma");
+async function createContext({ req, res }) {
+    const session = req.auth ?? null;
+    return { db: prisma_1.prisma, session, req, res };
+}

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export type { AppRouter } from "./routers/_app";
+export type { RouterInputs } from "./routers/_app";
+export type { RouterOutputs } from "./routers/_app";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,YAAY,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAChD,YAAY,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AACnD,YAAY,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC"}

package/dist/index.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/lib/auth.d.ts

@@ -0,0 +1,2 @@
+export declare const authRouter: (req: import("express").Request, res: import("express").Response, next: import("express").NextFunction) => Promise<void>;
+//# sourceMappingURL=auth.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"auth.d.ts","sourceRoot":"","sources":["../../src/lib/auth.ts"],"names":[],"mappings":"AAOA,eAAO,MAAM,UAAU,0HA0BnB,CAAA"}

package/dist/lib/auth.js

@@ -0,0 +1,37 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.authRouter = void 0;
+// src/server/auth.ts
+const express_1 = require("@auth/express");
+const prisma_adapter_1 = require("@auth/prisma-adapter");
+const prisma_1 = require("../lib/prisma");
+const google_1 = __importDefault(require("@auth/core/providers/google"));
+const credentials_1 = __importDefault(require("@auth/core/providers/credentials"));
+exports.authRouter = (0, express_1.ExpressAuth)({
+    providers: [
+        (0, google_1.default)({
+            clientId: process.env.GOOGLE_CLIENT_ID,
+            clientSecret: process.env.GOOGLE_CLIENT_SECRET,
+        }),
+        (0, credentials_1.default)({
+            name: "credentials",
+            credentials: {
+                email: { label: "Email", type: "email" },
+                password: { label: "Password", type: "password" },
+            },
+            async authorize(credentials) {
+                if (credentials?.email === "demo@example.com" &&
+                    credentials?.password === "demo") {
+                    return { id: "1", email: "demo@example.com", name: "Demo User" };
+                }
+                return null;
+            },
+        }),
+    ],
+    adapter: (0, prisma_adapter_1.PrismaAdapter)(prisma_1.prisma),
+    secret: process.env.AUTH_SECRET,
+    session: { strategy: "jwt" },
+});

package/dist/lib/prisma.d.ts

@@ -0,0 +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>;
+//# sourceMappingURL=prisma.d.ts.map

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

@@ -0,0 +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"}

package/dist/lib/prisma.js

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

package/dist/routers/_app.d.ts

@@ -0,0 +1,99 @@
+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>;
+        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>>;
+    };
+    meta: object;
+    errorShape: import("@trpc/server").TRPCDefaultErrorShape;
+    transformer: true;
+}, 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>;
+            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>>;
+        };
+        meta: object;
+        errorShape: import("@trpc/server").TRPCDefaultErrorShape;
+        transformer: true;
+    }, import("@trpc/server").TRPCDecorateCreateRouterOptions<{
+        signup: import("@trpc/server").TRPCMutationProcedure<{
+            input: {
+                name: string;
+                email: string;
+                password: string;
+            };
+            output: {
+                id: string;
+                email: string | null;
+                name: string | null;
+            };
+            meta: object;
+        }>;
+    }>>;
+    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>;
+            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>>;
+        };
+        meta: object;
+        errorShape: import("@trpc/server").TRPCDefaultErrorShape;
+        transformer: true;
+    }, import("@trpc/server").TRPCDecorateCreateRouterOptions<{
+        list: import("@trpc/server").TRPCQueryProcedure<{
+            input: void;
+            output: void;
+            meta: object;
+        }>;
+        create: import("@trpc/server").TRPCMutationProcedure<{
+            input: Record<string, never>;
+            output: void;
+            meta: object;
+        }>;
+        get: import("@trpc/server").TRPCQueryProcedure<{
+            input: {
+                id: string;
+            };
+            output: void;
+            meta: object;
+        }>;
+        update: import("@trpc/server").TRPCMutationProcedure<{
+            input: {
+                id: string;
+            };
+            output: void;
+            meta: object;
+        }>;
+        delete: import("@trpc/server").TRPCMutationProcedure<{
+            input: {
+                id: string;
+            };
+            output: void;
+            meta: object;
+        }>;
+        upload: import("@trpc/server").TRPCMutationProcedure<{
+            input: {
+                file: string;
+            };
+            output: void;
+            meta: object;
+        }>;
+        deleteFile: import("@trpc/server").TRPCMutationProcedure<{
+            input: {
+                fileId: string;
+            };
+            output: void;
+            meta: object;
+        }>;
+    }>>;
+}>>;
+export type AppRouter = typeof appRouter;
+export type RouterInputs = inferRouterInputs<AppRouter>;
+export type RouterOutputs = inferRouterOutputs<AppRouter>;
+//# sourceMappingURL=_app.d.ts.map

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

@@ -0,0 +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"}

package/dist/routers/_app.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.appRouter = void 0;
+const trpc_1 = require("../trpc");
+const auth_1 = require("./auth");
+const workspace_1 = require("./workspace");
+exports.appRouter = (0, trpc_1.router)({
+    auth: auth_1.auth,
+    workspace: workspace_1.workspace
+});

package/dist/routers/auth.d.ts

@@ -0,0 +1,26 @@
+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>;
+        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>>;
+    };
+    meta: object;
+    errorShape: import("@trpc/server").TRPCDefaultErrorShape;
+    transformer: true;
+}, import("@trpc/server").TRPCDecorateCreateRouterOptions<{
+    signup: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            name: string;
+            email: string;
+            password: string;
+        };
+        output: {
+            id: string;
+            email: string | null;
+            name: string | null;
+        };
+        meta: object;
+    }>;
+}>>;
+//# sourceMappingURL=auth.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"auth.d.ts","sourceRoot":"","sources":["../../src/routers/auth.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,IAAI;;;;;;;;;;;;;;;;;;;;;;;;GA4Bf,CAAC"}

package/dist/routers/auth.js

@@ -0,0 +1,35 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.auth = void 0;
+const zod_1 = require("zod");
+const trpc_1 = require("../trpc");
+const bcryptjs_1 = __importDefault(require("bcryptjs"));
+exports.auth = (0, trpc_1.router)({
+    signup: trpc_1.publicProcedure
+        .input(zod_1.z.object({
+        name: zod_1.z.string().min(1),
+        email: zod_1.z.string().email(),
+        password: zod_1.z.string().min(6),
+    }))
+        .mutation(async ({ ctx, input }) => {
+        const existing = await ctx.db.user.findUnique({
+            where: { email: input.email },
+        });
+        if (existing) {
+            throw new Error("Email already registered");
+        }
+        const hash = await bcryptjs_1.default.hash(input.password, 10);
+        const user = await ctx.db.user.create({
+            data: {
+                name: input.name,
+                email: input.email,
+                passwordHash: hash,
+                emailVerified: new Date(), // skip verification for demo
+            },
+        });
+        return { id: user.id, email: user.email, name: user.name };
+    }),
+});

package/dist/routers/sample.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sampleRouter = void 0;
+const zod_1 = require("zod");
+const trpc_1 = require("../trpc");
+exports.sampleRouter = (0, trpc_1.router)({
+    // GET-like: query without input
+    hello: trpc_1.publicProcedure.query(() => {
+        return { message: 'Hello from tRPC + Express 👋' };
+    }),
+    // Mutation with Zod input
+    echo: trpc_1.publicProcedure
+        .input(zod_1.z.object({ text: zod_1.z.string().min(1) }))
+        .mutation(({ input }) => {
+        return { echoed: input.text };
+    }),
+    // Authed query
+    me: trpc_1.authedProcedure.query(({ ctx }) => {
+        return { userId: ctx.user.id, role: ctx.user.role };
+    }),
+});

package/dist/routers/workspace.d.ts

@@ -0,0 +1,58 @@
+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>;
+        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>>;
+    };
+    meta: object;
+    errorShape: import("@trpc/server").TRPCDefaultErrorShape;
+    transformer: true;
+}, import("@trpc/server").TRPCDecorateCreateRouterOptions<{
+    list: import("@trpc/server").TRPCQueryProcedure<{
+        input: void;
+        output: void;
+        meta: object;
+    }>;
+    create: import("@trpc/server").TRPCMutationProcedure<{
+        input: Record<string, never>;
+        output: void;
+        meta: object;
+    }>;
+    get: import("@trpc/server").TRPCQueryProcedure<{
+        input: {
+            id: string;
+        };
+        output: void;
+        meta: object;
+    }>;
+    update: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            id: string;
+        };
+        output: void;
+        meta: object;
+    }>;
+    delete: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            id: string;
+        };
+        output: void;
+        meta: object;
+    }>;
+    upload: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            file: string;
+        };
+        output: void;
+        meta: object;
+    }>;
+    deleteFile: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            fileId: string;
+        };
+        output: void;
+        meta: object;
+    }>;
+}>>;
+//# sourceMappingURL=workspace.d.ts.map

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

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

package/dist/routers/workspace.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.workspace = void 0;
+const zod_1 = require("zod");
+const trpc_1 = require("../trpc");
+exports.workspace = (0, trpc_1.router)({
+    // Mutation with Zod input
+    list: trpc_1.publicProcedure
+        .query(async ({ ctx, input }) => {
+    }),
+    create: trpc_1.publicProcedure
+        .input(zod_1.z.object({}))
+        .mutation(({ input }) => {
+    }),
+    get: trpc_1.publicProcedure
+        .input(zod_1.z.object({
+        id: zod_1.z.string().uuid(),
+    }))
+        .query(({ input }) => {
+    }),
+    update: trpc_1.publicProcedure
+        .input(zod_1.z.object({
+        id: zod_1.z.string().uuid(),
+    }))
+        .mutation(({ input }) => {
+    }),
+    delete: trpc_1.publicProcedure
+        .input(zod_1.z.object({
+        id: zod_1.z.string().uuid(),
+    }))
+        .mutation(({ input }) => {
+    }),
+    upload: trpc_1.publicProcedure
+        .input(zod_1.z.object({
+        file: zod_1.z.string(),
+    }))
+        .mutation(({ input }) => {
+    }),
+    deleteFile: trpc_1.publicProcedure
+        .input(zod_1.z.object({
+        fileId: zod_1.z.string().uuid(),
+    }))
+        .mutation(({ input }) => {
+    }),
+});

package/dist/server.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=server.d.ts.map

package/dist/server.d.ts.map

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

package/dist/server.js

@@ -0,0 +1,75 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const express_1 = __importDefault(require("express"));
+const cors_1 = __importDefault(require("cors"));
+const helmet_1 = __importDefault(require("helmet"));
+const morgan_1 = __importDefault(require("morgan"));
+const compression_1 = __importDefault(require("compression"));
+const trpcExpress = __importStar(require("@trpc/server/adapters/express"));
+const auth_1 = require("./lib/auth");
+const _app_1 = require("./routers/_app");
+const context_1 = require("./context");
+const PORT = process.env.PORT ? Number(process.env.PORT) : 3001;
+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, morgan_1.default)('dev'));
+    app.use((0, compression_1.default)());
+    app.use(express_1.default.json());
+    app.use("/auth", auth_1.authRouter); // Auth routes live under /auth/*
+    // Health (plain Express)
+    app.get('/', (_req, res) => {
+        res.json({ ok: true, service: 'trpc-express', ts: Date.now() });
+    });
+    // tRPC mounted under /trpc
+    app.use('/trpc', trpcExpress.createExpressMiddleware({
+        router: _app_1.appRouter,
+        createContext: context_1.createContext,
+    }));
+    app.listen(PORT, () => {
+        console.log(`✅ Server ready on http://localhost:${PORT}`);
+        console.log(`➡️  tRPC endpoint at http://localhost:${PORT}/trpc`);
+    });
+}
+main().catch((err) => {
+    console.error('Failed to start server', err);
+    process.exit(1);
+});

package/dist/trpc.d.ts

@@ -0,0 +1,41 @@
+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>;
+        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>>;
+    };
+    meta: object;
+    errorShape: import("@trpc/server").TRPCDefaultErrorShape;
+    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>;
+    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>;
+    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>;
+    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>;
+    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>;
+    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/dist/trpc.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"trpc.d.ts","sourceRoot":"","sources":["../src/trpc.ts"],"names":[],"mappings":"AAWA,eAAO,MAAM,MAAM;;;;;;;;;;EAAW,CAAC;AAC/B,eAAO,MAAM,UAAU;;;;;;;;;;sCAAe,CAAC;AACvC,eAAO,MAAM,eAAe;;;;;yLAAc,CAAC;AAsB3C,gCAAgC;AAChC,eAAO,MAAM,eAAe;;;;;;;;;;yKAAgC,CAAC"}

package/dist/trpc.js

@@ -0,0 +1,38 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.authedProcedure = exports.publicProcedure = exports.middleware = exports.router = void 0;
+const server_1 = require("@trpc/server");
+const superjson_1 = __importDefault(require("superjson"));
+const t = server_1.initTRPC.context().create({
+    transformer: superjson_1.default,
+    errorFormatter({ shape }) {
+        return shape;
+    },
+});
+exports.router = t.router;
+exports.middleware = t.middleware;
+exports.publicProcedure = t.procedure;
+/** Middleware that enforces authentication */
+const isAuthed = (0, exports.middleware)(({ ctx, next }) => {
+    if (!ctx.session?.user?.id) {
+        throw new server_1.TRPCError({ code: "UNAUTHORIZED" });
+    }
+    return next({
+        ctx: {
+            ...ctx,
+            // refine ctx: session is guaranteed, user.id is string
+            session: {
+                ...ctx.session,
+                user: {
+                    ...ctx.session.user,
+                    id: ctx.session.user.id, // typed non-null
+                },
+            },
+        },
+    });
+});
+/** Exported authed procedure */
+exports.authedProcedure = exports.publicProcedure.use(isAuthed);

package/package.json

@@ -1,8 +1,15 @@
 {
   "name": "@goscribe/server",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "description": "",
-  "main": "index.js",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
   "scripts": {
     "dev": "ts-node-dev --respawn --transpile-only src/server.ts",
     "build": "tsc -p .",

package/prisma/schema.prisma

@@ -140,8 +140,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/index.ts

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

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,3 +1,4 @@
+import { inferRouterInputs, inferRouterOutputs } from '@trpc/server';
 import { router } from '../trpc';
 import { auth } from './auth';
 import { workspace } from './workspace';
@@ -9,3 +10,5 @@ export const appRouter = router({
 
 // Export type for client inference
 export type AppRouter = typeof appRouter;
+export type RouterInputs = inferRouterInputs<AppRouter>;
+export type RouterOutputs = inferRouterOutputs<AppRouter>;

package/src/routers/workspace.ts

@@ -1,51 +1,156 @@
 import { z } from 'zod';
 import { router, publicProcedure, authedProcedure } from '../trpc';
+import { bucket } from 'src/lib/storage';
 
 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) => {
+        fileRecords.forEach((file) => {
+          if (file.bucket && file.objectKey) {
+            const gcsFile = 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

@@ -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/tsconfig.json

@@ -3,11 +3,15 @@
     "target": "ES2020",
     "module": "CommonJS",
     "moduleResolution": "node",
-    "outDir": "dist",
-    "rootDir": "src",
-    "strict": true,
     "esModuleInterop": true,
-    "skipLibCheck": true
+    "strict": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "outDir": "dist",
+    "baseUrl": ".", 
+    "declaration": true,
+    "declarationMap": true
   },
-  "include": ["src"]
-}
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}