wip

functions/add-card.ts

@@ -37,8 +37,7 @@ export const onRequestPost = handleError(async ({ request, env }) => {
   const canEdit = await getDeckByIdAndAuthorId(
     envSafe,
     input.data.deckId,
-    user.id,
-    user.is_admin,
+    user,
   );
   if (!canEdit) {
     return createForbiddenRequestResponse();

functions/add-deck-access.ts

@@ -0,0 +1,53 @@
+import { handleError } from "./lib/handle-error/handle-error.ts";
+import { getUser } from "./services/get-user.ts";
+import { createAuthFailedResponse } from "./lib/json-response/create-auth-failed-response.ts";
+import { createBadRequestResponse } from "./lib/json-response/create-bad-request-response.ts";
+import { z } from "zod";
+import { getDeckByIdAndAuthorId } from "./db/deck/get-deck-by-id-and-author-id.ts";
+import { envSchema } from "./env/env-schema.ts";
+import { createForbiddenRequestResponse } from "./lib/json-response/create-forbidden-request-response.ts";
+import { createJsonResponse } from "./lib/json-response/create-json-response.ts";
+import { createDeckAccessDb } from "./db/deck-access/create-deck-access-db.ts";
+
+const requestSchema = z.object({
+  deckId: z.number(),
+  durationDays: z.number().nullable(),
+});
+
+const responseSchema = z.object({
+  share_id: z.string(),
+});
+
+export type AddDeckAccessRequest = z.infer<typeof requestSchema>;
+export type AddDeckAccessResponse = z.infer<typeof responseSchema>;
+
+export const onRequestPost = handleError(async ({ request, env }) => {
+  const user = await getUser(request, env);
+  if (!user) return createAuthFailedResponse();
+  const input = requestSchema.safeParse(await request.json());
+  if (!input.success) {
+    return createBadRequestResponse();
+  }
+
+  const envSafe = envSchema.parse(env);
+  const canEdit = await getDeckByIdAndAuthorId(
+    envSafe,
+    input.data.deckId,
+    user,
+  );
+  if (!canEdit) {
+    return createForbiddenRequestResponse();
+  }
+
+  const createDeckAccessResult = await createDeckAccessDb(
+    envSafe,
+    user.id,
+    input.data.deckId,
+    input.data.durationDays,
+  );
+
+  return createJsonResponse<AddDeckAccessResponse>(
+    responseSchema.parse(createDeckAccessResult),
+    200,
+  );
+});

functions/db/databaseTypes.ts

@@ -109,27 +109,30 @@ export interface Database {
           author_id: number
           created_at: string
           deck_id: number
+          duration_days: number | null
           id: number
-          is_used: boolean
           share_id: string
+          usage_started_at: string | null
           used_by: number | null
         }
         Insert: {
           author_id: number
           created_at?: string
           deck_id: number
+          duration_days?: number | null
           id?: number
-          is_used?: boolean
           share_id: string
+          usage_started_at?: string | null
           used_by?: number | null
         }
         Update: {
           author_id?: number
           created_at?: string
           deck_id?: number
+          duration_days?: number | null
           id?: number
-          is_used?: boolean
           share_id?: string
+          usage_started_at?: string | null
           used_by?: number | null
         }
         Relationships: [

functions/db/deck-access/create-deck-access-db.ts

@@ -0,0 +1,30 @@
+import { EnvSafe } from "../../env/env-schema.ts";
+import { shortUniqueId } from "../../lib/short-unique-id/short-unique-id.ts";
+import { DatabaseException } from "../database-exception.ts";
+import { getDatabase } from "../get-database.ts";
+
+export const createDeckAccessDb = async (
+  envSafe: EnvSafe,
+  userId: number,
+  deckId: number,
+  durationDays: number | null,
+) => {
+  const db = getDatabase(envSafe);
+
+  const createDeckAccessResult = await db
+    .from("deck_access")
+    .insert({
+      deck_id: deckId,
+      author_id: userId,
+      share_id: shortUniqueId(),
+      duration_days: durationDays,
+    })
+    .select()
+    .single();
+
+  if (createDeckAccessResult.error) {
+    throw new DatabaseException(createDeckAccessResult.error);
+  }
+
+  return createDeckAccessResult.data;
+};

functions/db/deck-access/get-deck-access-by-share-id-db.ts

@@ -0,0 +1,29 @@
+import { DatabaseException } from "../database-exception.ts";
+import { getDatabase } from "../get-database.ts";
+import { EnvSafe } from "../../env/env-schema.ts";
+import { z } from "zod";
+
+const resultSchema = z.object({
+  deck_id: z.number(),
+  author_id: z.number(),
+  used_by: z.number().nullable(),
+});
+
+export const getDeckAccessByShareIdDb = async (
+  envSafe: EnvSafe,
+  shareId: string,
+) => {
+  const db = getDatabase(envSafe);
+
+  const oneTimeShareLinkResult = await db
+    .from("deck_access")
+    .select("deck_id, author_id, used_by")
+    .eq("share_id", shareId)
+    .single();
+
+  if (oneTimeShareLinkResult.error) {
+    throw new DatabaseException(oneTimeShareLinkResult.error);
+  }
+
+  return resultSchema.parse(oneTimeShareLinkResult.data);
+};

functions/db/deck-access/get-last-deck-accesses-for-deck-db.ts

@@ -0,0 +1,25 @@
+import { DatabaseException } from "../database-exception.ts";
+import { getDatabase } from "../get-database.ts";
+import { EnvSafe } from "../../env/env-schema.ts";
+
+export const getLastDeckAccessesForDeckDb = async (
+  envSafe: EnvSafe,
+  deckId: number,
+) => {
+  const db = getDatabase(envSafe);
+
+  const { data, error } = await db
+    .from("deck_access")
+    .select(
+      "deck_id, author_id, used_by, share_id, id, created_at, duration_days",
+    )
+    .eq("deck_id", deckId)
+    .order("created_at", { ascending: false })
+    .limit(100);
+
+  if (error) {
+    throw new DatabaseException(error);
+  }
+
+  return data;
+};

functions/db/deck-access/start-using-deck-access-db.ts

@@ -0,0 +1,24 @@
+import { getDatabase } from "../get-database.ts";
+import { EnvSafe } from "../../env/env-schema.ts";
+import { DatabaseException } from "../database-exception.ts";
+
+export const startUsingDeckAccessDb = async (
+  envSafe: EnvSafe,
+  userId: number,
+  shareId: string,
+) => {
+  const db = getDatabase(envSafe);
+
+  const updateResult = await db
+    .from("deck_access")
+    .update({
+      used_by: userId,
+      usage_started_at: new Date().toISOString(),
+    })
+    .eq("share_id", shareId)
+    .single();
+
+  if (updateResult.error) {
+    throw new DatabaseException(updateResult.error);
+  }
+};

functions/db/deck/decks-with-cards-schema.ts

@@ -17,7 +17,7 @@ export const deckSchema = z.object({
   name: z.string(),
   author_id: z.number().nullable(),
   description: z.string().nullable(),
-  share_id: z.string().nullable(),
+  share_id: z.string(),
   is_public: z.boolean(),
   speak_locale: z.string().nullable(),
   speak_field: deckSpeakField.nullable(),

functions/db/deck/get-deck-by-id-and-author-id.ts

@@ -5,19 +5,16 @@ import { DatabaseException } from "../database-exception.ts";
 export const getDeckByIdAndAuthorId = async (
   envSafe: EnvSafe,
   deckId: number,
-  userId: number,
-  isAdmin: boolean,
+  user: { id: number; is_admin: boolean },
 ) => {
   const db = getDatabase(envSafe);
 
   let query = db.from("deck").select().eq("id", deckId);
-
-  if (!isAdmin) {
-    query = query.eq("author_id", userId);
+  if (!user.is_admin) {
+    query = query.eq("author_id", user.id);
   }
 
   const canEditDeckResult = await query.single();
-
   if (canEditDeckResult.error) {
     throw new DatabaseException(canEditDeckResult.error);
   }

functions/db/deck/get-deck-with-cards-by-id-db.ts

@@ -6,16 +6,16 @@ import { getDatabase } from "../get-database.ts";
 export const getDeckWithCardsById = async (env: EnvSafe, deckId: number) => {
   const db = getDatabase(env);
 
-  const { data, error } = await db
+  const stableShareLinkResult = await db
     .from("deck")
     .select("*, deck_card!deck_card_deck_id_fkey(*)")
     .eq("id", deckId)
     .limit(1)
     .single();
 
-  if (error) {
-    throw new DatabaseException(error);
+  if (stableShareLinkResult.error) {
+    throw new DatabaseException(stableShareLinkResult.error);
   }
 
-  return deckWithCardsSchema.parse(data);
+  return deckWithCardsSchema.parse(stableShareLinkResult.data);
 };

functions/db/deck/get-deck-with-cards-by-share-id-db.ts

@@ -0,0 +1,24 @@
+import { DatabaseException } from "../database-exception.ts";
+import { deckWithCardsSchema } from "./decks-with-cards-schema.ts";
+import { EnvSafe } from "../../env/env-schema.ts";
+import { getDatabase } from "../get-database.ts";
+
+export const getDeckWithCardsByShareIdDb = async (
+  env: EnvSafe,
+  shareId: string,
+) => {
+  const db = getDatabase(env);
+
+  const { data, error } = await db
+    .from("deck")
+    .select("*, deck_card!deck_card_deck_id_fkey(*)")
+    .eq("share_id", shareId)
+    .limit(1)
+    .single();
+
+  if (error) {
+    throw new DatabaseException(error);
+  }
+
+  return deckWithCardsSchema.parse(data);
+};

functions/deck-accesses.ts

@@ -3,16 +3,23 @@ import { getUser } from "./services/get-user.ts";
 import { createAuthFailedResponse } from "./lib/json-response/create-auth-failed-response.ts";
 import { handleError } from "./lib/handle-error/handle-error.ts";
 import { envSchema } from "./env/env-schema.ts";
-import { getDatabase } from "./db/get-database.ts";
-import { DatabaseException } from "./db/database-exception.ts";
 import { createBadRequestResponse } from "./lib/json-response/create-bad-request-response.ts";
+import { getLastDeckAccessesForDeckDb } from "./db/deck-access/get-last-deck-accesses-for-deck-db.ts";
+import { z } from "zod";
 
-export type DeckAccessesOfDeckResponse = {
-  accesses: Array<{
-    used_by: number | null;
-    share_id: string;
-  }>;
-};
+const responseSchema = z.object({
+  accesses: z.array(
+    z.object({
+      used_by: z.number().nullable(),
+      share_id: z.string(),
+      id: z.number(),
+      created_at: z.string(),
+      duration_days: z.number().nullable(),
+    }),
+  ),
+});
+
+export type DeckAccessesForDeckTypeDb = z.infer<typeof responseSchema>;
 
 export const onRequest = handleError(async ({ request, env }) => {
   const user = await getUser(request, env);
@@ -25,19 +32,10 @@ export const onRequest = handleError(async ({ request, env }) => {
   }
 
   const envSafe = envSchema.parse(env);
-  const db = getDatabase(envSafe);
 
-  const { data, error } = await db
-    .from("deck_access")
-    .select("deck_id, author_id, used_by, share_id")
-    .eq("deck_id", deckId)
-    .limit(100);
-
-  if (error) {
-    throw new DatabaseException(error);
-  }
+  const data = await getLastDeckAccessesForDeckDb(envSafe, Number(deckId));
 
-  return createJsonResponse<DeckAccessesOfDeckResponse>({
+  return createJsonResponse<DeckAccessesForDeckTypeDb>({
     accesses: data,
   });
 });