@donotdev/functions 0.0.4 → 0.0.6

package/src/firebase/oauth/githubAccess.ts

@@ -26,6 +26,15 @@ import {
 import { handleError } from '../../shared/errorHandling.js';
 import { GitHubApiService } from '../../shared/index.js';
 import { assertAuthenticated } from '../../shared/utils.js';
+import { AUTH_CONFIG } from '../config/constants.js';
+import { githubPersonalAccessToken } from '../config/secrets.js';
+
+import type { CallableFunction } from 'firebase-functions/v2/https';
+
+const OAUTH_CONFIG = {
+  ...AUTH_CONFIG,
+  secrets: [githubPersonalAccessToken],
+};
 
 /**
  * Internal function that accepts custom schema
@@ -66,7 +75,7 @@ async function grantGitHubAccessInternal(
     } = validatedData;
 
     // Get GitHub token
-    const githubToken = process.env.GITHUB_PERSONAL_ACCESS_TOKEN;
+    const githubToken = githubPersonalAccessToken.value();
     if (!githubToken) {
       throw handleError(
         new Error('GitHub Personal Access Token not configured')
@@ -139,7 +148,11 @@ async function grantGitHubAccessInternal(
  * @since 0.0.1
  * @author AMBROISE PARK Consulting
  */
-export const grantGitHubAccess = onCall<GrantGitHubAccessRequest>(
+export const grantGitHubAccess: CallableFunction<
+  GrantGitHubAccessRequest,
+  Promise<any>
+> = onCall<GrantGitHubAccessRequest>(
+  OAUTH_CONFIG,
   async (request: CallableRequest<GrantGitHubAccessRequest>) => {
     return await grantGitHubAccessInternal(request);
   }
@@ -195,7 +208,7 @@ async function revokeGitHubAccessInternal(
     const { userId, githubUsername, repoConfig } = validationResult.output;
 
     // Get GitHub token
-    const githubToken = process.env.GITHUB_PERSONAL_ACCESS_TOKEN;
+    const githubToken = githubPersonalAccessToken.value();
     if (!githubToken) {
       throw handleError(
         new Error('GitHub Personal Access Token not configured')
@@ -264,7 +277,11 @@ async function revokeGitHubAccessInternal(
  * @since 0.0.1
  * @author AMBROISE PARK Consulting
  */
-export const revokeGitHubAccess = onCall<RevokeGitHubAccessRequest>(
+export const revokeGitHubAccess: CallableFunction<
+  RevokeGitHubAccessRequest,
+  Promise<any>
+> = onCall<RevokeGitHubAccessRequest>(
+  OAUTH_CONFIG,
   async (request: CallableRequest<RevokeGitHubAccessRequest>) => {
     return await revokeGitHubAccessInternal(request);
   }
@@ -320,7 +337,7 @@ async function checkGitHubAccessInternal(
     const { userId, githubUsername, repoConfig } = validationResult.output;
 
     // Get GitHub token
-    const githubToken = process.env.GITHUB_PERSONAL_ACCESS_TOKEN;
+    const githubToken = githubPersonalAccessToken.value();
     if (!githubToken) {
       throw handleError(
         new Error('GitHub Personal Access Token not configured')
@@ -369,7 +386,11 @@ async function checkGitHubAccessInternal(
  * @since 0.0.1
  * @author AMBROISE PARK Consulting
  */
-export const checkGitHubAccess = onCall<CheckGitHubAccessRequest>(
+export const checkGitHubAccess: CallableFunction<
+  CheckGitHubAccessRequest,
+  Promise<any>
+> = onCall<CheckGitHubAccessRequest>(
+  OAUTH_CONFIG,
   async (request: CallableRequest<CheckGitHubAccessRequest>) => {
     return await checkGitHubAccessInternal(request);
   }

package/src/shared/schema.ts

@@ -11,13 +11,16 @@
 
 import * as v from 'valibot';
 
+/** Visibility levels matching @donotdev/core */
+type Visibility = 'guest' | 'user' | 'admin' | 'technical' | 'hidden';
+
 // Define a type for the custom visibility property we might add to Valibot schemas
 interface ValibotSchemaWithVisibility extends v.BaseSchema<
   unknown,
   any,
   v.BaseIssue<unknown>
 > {
-  visibility?: 'public' | 'admin';
+  visibility?: Visibility;
 }
 
 /**
@@ -25,13 +28,13 @@ interface ValibotSchemaWithVisibility extends v.BaseSchema<
  * Looks for a custom 'visibility' property on the schema object.
  *
  * @param field - A Valibot schema field (e.g., v.string()).
- * @returns The visibility setting ('public' or 'admin') if found, otherwise undefined.
+ * @returns The visibility setting if found, otherwise undefined.
  *
- * @version 0.0.1
+ * @version 0.0.2
  * @since 0.0.1
  * @author AMBROISE PARK Consulting
  */
-function getFieldVisibility(field: any): 'public' | 'admin' | undefined {
+function getFieldVisibility(field: any): Visibility | undefined {
   // Check if the field has visibility property
   if (field && typeof field === 'object' && 'visibility' in field) {
     return (field as ValibotSchemaWithVisibility).visibility;
@@ -41,38 +44,59 @@ function getFieldVisibility(field: any): 'public' | 'admin' | undefined {
 
 /**
  * Determines if a field should be visible based on its visibility setting
- * and the user's administrative status.
+ * and the user's authentication/admin status.
  *
- * Rules:
- * - If visibility is 'public', it's always visible.
- * - If visibility is 'admin', it's visible only if isAdmin is true.
- * - If visibility is undefined (not set), the field is considered internal/technical
- * and is visible only to admins AND if its key starts with an underscore '_'.
- * - Fields without an underscore prefix and undefined visibility are hidden by default.
+ * Visibility levels:
+ * - 'guest': Always visible (even to unauthenticated users)
+ * - 'user': Visible to authenticated users (users see both guest and user fields)
+ * - 'admin': Visible only to admins
+ * - 'technical': Visible to admins only (shown as read-only in edit forms)
+ * - 'hidden': Never visible (passwords, tokens, API keys - only in DB)
+ * - undefined: Defaults to 'user' behavior (visible to authenticated users)
  *
  * @param key - The name (key) of the field.
- * @param visibility - The visibility setting ('public', 'admin', or undefined).
+ * @param visibility - The visibility setting.
  * @param isAdmin - Whether the current user is an admin.
+ * @param isAuthenticated - Whether the current user is authenticated (defaults to true for backward compat).
  * @returns True if the field should be visible, false otherwise.
  *
- * @version 0.0.1
+ * @version 0.0.2
  * @since 0.0.1
  * @author AMBROISE PARK Consulting
  */
 export function isFieldVisible(
   key: string,
-  visibility: 'public' | 'admin' | undefined,
-  isAdmin: boolean
+  visibility: Visibility | undefined,
+  isAdmin: boolean,
+  isAuthenticated: boolean = true
 ): boolean {
-  if (visibility === 'public') {
-    return true; // Public fields are always visible
+  // Hidden fields are never exposed
+  if (visibility === 'hidden') {
+    return false;
+  }
+
+  // Guest fields are always visible
+  if (visibility === 'guest') {
+    return true;
   }
+
+  // Admin fields are visible only to admins
   if (visibility === 'admin') {
-    return isAdmin; // Admin fields are visible only to admins
+    return isAdmin;
+  }
+
+  // Technical fields are visible only to admins
+  if (visibility === 'technical') {
+    return isAdmin;
   }
-  // If visibility is undefined:
-  // Only show if it's an admin AND the key starts with '_' (internal field convention)
-  return isAdmin && key.startsWith('_');
+
+  // User fields (or undefined/default) are visible to authenticated users
+  if (visibility === 'user' || visibility === undefined) {
+    return isAuthenticated;
+  }
+
+  // Fallback: hide unknown visibility levels
+  return false;
 }
 
 /**

package/src/shared/utils.ts

@@ -46,9 +46,24 @@ export function getAuth() {
   return getFirebaseAdminAuth();
 }
 
-// Lazy initialization of Stripe to avoid errors during Firebase analysis
+// Lazy initialization of Stripe
 let _stripe: Stripe | null = null;
 
+/**
+ * Initialize Stripe explicitly (e.g. with a secret from defineSecret)
+ * @param apiKey - Stripe secret key
+ */
+export function initStripe(apiKey: string) {
+  if (!apiKey) throw new Error('Stripe API key is required');
+
+  const apiVersion = process.env.STRIPE_API_VERSION || '2024-12-18.acacia'; // Fallback or strict latest
+
+  _stripe = new Stripe(apiKey, {
+    apiVersion: apiVersion as any,
+  });
+  return _stripe;
+}
+
 /**
  * Get Stripe instance with lazy initialization
  *
@@ -58,21 +73,18 @@ let _stripe: Stripe | null = null;
  */
 export function getStripe(): Stripe {
   if (!_stripe) {
+    // Legacy/Vercel fallback: Try process.env
     const STRIPE_SECRET_KEY = process.env.STRIPE_SECRET_KEY;
-    if (!STRIPE_SECRET_KEY) {
-      throw new Error('STRIPE_SECRET_KEY environment variable is required');
-    }
-
-    const STRIPE_API_VERSION = process.env.STRIPE_API_VERSION;
-    if (!STRIPE_API_VERSION) {
-      throw new Error('STRIPE_API_VERSION environment variable is required');
+    if (STRIPE_SECRET_KEY) {
+      initStripe(STRIPE_SECRET_KEY);
+    } else {
+      throw new Error(
+        'Stripe not initialized. Call initStripe() or set STRIPE_SECRET_KEY env var.'
+      );
     }
-
-    _stripe = new Stripe(STRIPE_SECRET_KEY, {
-      apiVersion: STRIPE_API_VERSION as any,
-    });
   }
-  return _stripe;
+  // We know _stripe is set here or we threw
+  return _stripe!;
 }
 
 /**
@@ -110,6 +122,7 @@ export function assertAuthenticated(auth: any): string {
  * @author AMBROISE PARK Consulting
  */
 export function validateStripeEnvironment(): void {
+  // Functions v2 automatically injects secrets as process.env when declared in config
   const STRIPE_SECRET_KEY = process.env.STRIPE_SECRET_KEY;
   if (!STRIPE_SECRET_KEY) {
     throw new Error('Missing STRIPE_SECRET_KEY environment variable');

package/src/vercel/api/crud/create.ts

@@ -10,6 +10,7 @@
  */
 
 import type { CreateEntityData } from '@donotdev/core/server';
+import { DEFAULT_STATUS_VALUE } from '@donotdev/core/server';
 
 import { handleError } from '../../../shared/errorHandling.js';
 import { getFirebaseAdminFirestore } from '@donotdev/firebase/server';
@@ -44,12 +45,21 @@ export default async function handler(
       throw handleError(new Error('Missing schema or payload'));
     }
 
+    // Determine status (default to draft if not provided)
+    const status = payload.status ?? DEFAULT_STATUS_VALUE;
+    const isDraft = status === 'draft';
+
     // Validate the document against the schema
-    validateDocument(payload as Record<string, any>, schema);
+    // Skip validation for drafts - required fields can be incomplete
+    if (!isDraft) {
+      validateDocument(payload as Record<string, any>, schema);
+    }
 
     // Prepare the document for Firestore and add metadata
+    // Always ensure status is set
     const documentData = {
       ...prepareForFirestore(payload),
+      status, // Ensure status is always present
       ...createMetadata(uid),
     };
 

package/src/vercel/api/crud/get.ts

@@ -10,6 +10,7 @@
  */
 
 import type { GetEntityData } from '@donotdev/core/server';
+import { HIDDEN_STATUSES } from '@donotdev/core/server';
 
 import { handleError } from '../../../shared/errorHandling.js';
 import { transformFirestoreData } from '../../../shared/index.js';
@@ -49,10 +50,16 @@ export default async function handler(
       throw handleError(new Error('Document not found'));
     }
 
+    // Hide drafts/deleted (Vercel routes treat all requests as non-admin)
+    const docData = doc.data();
+    if ((HIDDEN_STATUSES as readonly string[]).includes(docData?.status)) {
+      throw handleError(new Error('Document not found'));
+    }
+
     // Transform the document data
     const documentData = transformFirestoreData({
       id: doc.id,
-      ...doc.data(),
+      ...docData,
     });
 
     // Filter visible fields based on schema

package/src/vercel/api/crud/list.ts

@@ -10,6 +10,7 @@
  */
 
 import type { ListEntityData } from '@donotdev/core/server';
+import { HIDDEN_STATUSES } from '@donotdev/core/server';
 
 import { handleError } from '../../../shared/errorHandling.js';
 import { transformFirestoreData } from '../../../shared/index.js';
@@ -50,6 +51,9 @@ export default async function handler(
     let query: FirebaseFirestore.Query<FirebaseFirestore.DocumentData> =
       db.collection(schema.metadata.collection);
 
+    // Filter out hidden statuses (Vercel routes treat all requests as non-admin)
+    query = query.where('status', 'not-in', [...HIDDEN_STATUSES]);
+
     // Apply limit and offset
     query = query.limit(parseInt(limit as string));
     query = query.offset(parseInt(offset as string));

package/src/vercel/api/crud/update.ts

@@ -10,6 +10,7 @@
  */
 
 import type { UpdateEntityData } from '@donotdev/core/server';
+import { DEFAULT_STATUS_VALUE } from '@donotdev/core/server';
 
 import { handleError } from '../../../shared/errorHandling.js';
 import { getFirebaseAdminFirestore } from '@donotdev/firebase/server';
@@ -44,8 +45,29 @@ export default async function handler(
       throw handleError(new Error('Missing schema, id, or payload'));
     }
 
+    const db = getFirebaseAdminFirestore();
+
+    // Get current document to merge with payload for status check
+    const currentDoc = await db
+      .collection(schema.metadata.collection)
+      .doc(id)
+      .get();
+
+    if (!currentDoc.exists) {
+      throw handleError(new Error('Document not found'));
+    }
+
+    // Merge current data with payload to determine resulting status
+    const currentData = currentDoc.data() || {};
+    const mergedData = { ...currentData, ...payload };
+    const resultingStatus = mergedData.status ?? DEFAULT_STATUS_VALUE;
+    const isDraft = resultingStatus === 'draft';
+
     // Validate the document against the schema
-    validateDocument(payload as Record<string, any>, schema);
+    // Skip validation for drafts - required fields can be incomplete
+    if (!isDraft) {
+      validateDocument(mergedData as Record<string, any>, schema);
+    }
 
     // Prepare the document for Firestore and add metadata
     const documentData = {
@@ -54,7 +76,6 @@ export default async function handler(
     };
 
     // Update the document in Firestore
-    const db = getFirebaseAdminFirestore();
     await db
       .collection(schema.metadata.collection)
       .doc(id)