@cravery/core 0.0.2 → 0.0.4

package/src/lib/api.ts

@@ -0,0 +1,90 @@
+import {
+  onCall,
+  HttpsError,
+  CallableRequest,
+  CallableOptions,
+} from "firebase-functions/v2/https";
+import { z } from "zod";
+import { isAdmin, isModerator } from "./iam";
+
+const DEFAULT_OPTIONS: CallableOptions = { cors: true, enforceAppCheck: true };
+
+const handleError = (error: unknown): never => {
+  if (error instanceof z.ZodError) {
+    throw new HttpsError(
+      "invalid-argument",
+      `Validation failed: ${error.message}`,
+    );
+  }
+  if (error instanceof HttpsError) {
+    throw error;
+  }
+  throw new HttpsError(
+    "internal",
+    error instanceof Error ? error.message : "Unknown error",
+  );
+};
+
+class CallableBuilder<T> {
+  private requiresAuth = false;
+  private requiresAdmin = false;
+  private requiresModerator = false;
+  private options: CallableOptions = DEFAULT_OPTIONS;
+
+  constructor(private schema: z.ZodSchema<T>) {}
+
+  withOptions(options: CallableOptions) {
+    this.options = { ...DEFAULT_OPTIONS, ...options };
+    return this;
+  }
+
+  requireUser() {
+    this.requiresAuth = true;
+    return this;
+  }
+
+  requireAdmin() {
+    this.requiresAuth = true;
+    this.requiresAdmin = true;
+    return this;
+  }
+
+  requireModerator() {
+    this.requiresAuth = true;
+    this.requiresModerator = true;
+    return this;
+  }
+
+  handle<R>(handler: (data: T, request: CallableRequest) => Promise<R>) {
+    return onCall(this.options, async (request) => {
+      if (this.requiresAuth && !request.auth) {
+        throw new HttpsError("unauthenticated", "Authentication required");
+      }
+
+      if (request.auth) {
+        const uid = request.auth.uid;
+
+        if (this.requiresAdmin && !(await isAdmin(uid))) {
+          throw new HttpsError("permission-denied", "Admin access required");
+        }
+
+        if (this.requiresModerator && !(await isModerator(uid))) {
+          throw new HttpsError(
+            "permission-denied",
+            "Moderator access required",
+          );
+        }
+      }
+
+      try {
+        const data = this.schema.parse(request.data);
+        return await handler(data, request);
+      } catch (error) {
+        throw handleError(error);
+      }
+    });
+  }
+}
+
+export const callable = <T>(schema: z.ZodSchema<T>) =>
+  new CallableBuilder(schema);

package/src/lib/firebase.ts

@@ -0,0 +1,5 @@
+import { getFirestore } from "firebase-admin/firestore";
+import { getDatabase } from "firebase-admin/database";
+
+export const firestore = getFirestore();
+export const rtdb = getDatabase();

package/src/lib/iam.ts

@@ -0,0 +1,22 @@
+import * as admin from "firebase-admin";
+import { Role } from "../enums";
+
+const getUserRole = async (uid: string): Promise<Role> => {
+  let role: Role = "guest";
+  const userDoc = await admin.firestore().collection("users").doc(uid).get();
+  if (userDoc.exists) {
+    const userData = userDoc.data();
+    role = userData?.role || "user";
+  }
+  return role;
+};
+
+export const isAdmin = async (uid: string): Promise<boolean> => {
+  const role = await getUserRole(uid);
+  return role === "admin";
+};
+
+export const isModerator = async (uid: string): Promise<boolean> => {
+  const role = await getUserRole(uid);
+  return role === "admin" || role === "moderator";
+};

package/src/lib/index.ts

@@ -0,0 +1,6 @@
+export * from "./ai";
+export * from "./api";
+export * from "./firebase";
+export * from "./iam";
+export * from "./repository";
+export * from "./storage";

package/src/lib/repository/errors.ts

@@ -0,0 +1,37 @@
+export enum RepositoryErrorCode {
+  NOT_FOUND = "NOT_FOUND",
+  ALREADY_EXISTS = "ALREADY_EXISTS",
+  VALIDATION_ERROR = "VALIDATION_ERROR",
+  QUERY_LIMIT_EXCEEDED = "QUERY_LIMIT_EXCEEDED",
+  TRANSACTION_FAILED = "TRANSACTION_FAILED",
+  PERMISSION_DENIED = "PERMISSION_DENIED",
+}
+
+export class RepositoryError extends Error {
+  public readonly code: RepositoryErrorCode;
+  public readonly context?: Record<string, unknown>;
+
+  constructor(
+    code: RepositoryErrorCode,
+    message: string,
+    context?: Record<string, unknown>,
+  ) {
+    super(message);
+    this.name = "RepositoryError";
+    this.code = code;
+    this.context = context;
+
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, RepositoryError);
+    }
+  }
+
+  toJSON() {
+    return {
+      name: this.name,
+      code: this.code,
+      message: this.message,
+      context: this.context,
+    };
+  }
+}