595 lines
17 KiB
TypeScript
595 lines
17 KiB
TypeScript
// Connect to a KV instance await Deno.openKv("https://api.deno.com/databases/05af0e7a-a39f-44c8-a6fe-f52bacede61c/connect");
|
|
//const kv = await Deno.openKv("https://api.deno.com/databases/35aded84-9959-4723-9906-13380079a56c/connect");
|
|
//const kv = await openKv("https://api.deno.com/databases/05af0e7a-a39f-44c8-a6fe-f52bacede61c/connect");
|
|
//import { kv } from "npm:deno/kv";
|
|
//const kv = await Deno.open("",);
|
|
//import { openKv } from "npm:@deno/kv";
|
|
|
|
import { cloneObjectExcept, jsonMerge, KvObj, SessionConfig } from "./types.ts";
|
|
//import { bucket } from "./gcs_client.ts";
|
|
import { kvStore } from "../modules/KvCacheStore.ts";
|
|
|
|
//export let REDIRECT_URI = "https://studymylanguage.com/api/callback";
|
|
//export let REDIRECT_URI = "http://localhost:8000/api/callback";
|
|
export const REDIRECT_URI = Deno.env.get("REDIRECT_URL") + "/api/callback";
|
|
|
|
export interface GoogleUser {
|
|
id: string;
|
|
email: string;
|
|
verified_email: boolean;
|
|
name: string;
|
|
given_name: string;
|
|
family_name: string;
|
|
picture: string;
|
|
}
|
|
|
|
export interface AccessTokenResponse {
|
|
owner_id: string; // TODO: Make this required to be unuqe for each row in the table
|
|
access_token: string;
|
|
token_type: string;
|
|
expires_in?: number;
|
|
refresh_token?: string;
|
|
scope?: string;
|
|
}
|
|
|
|
const isDeploy = Deno.env.get("DENO_DEPLOYMENT_ID") !== undefined;
|
|
if (!isDeploy) {
|
|
Deno.env.set("APP_KEY", "12345678901123456789011234567890");
|
|
Deno.env.set(
|
|
"DENO_KV_ACCESS_TOKEN",
|
|
"ddp_2ZM4j8SSkfe13gPlMJhEaFjr23UxDJ1JR2N1",
|
|
);
|
|
//REDIRECT_URI = "http://localhost:8000/api/callback";
|
|
//REDIRECT_URI = "https://devcontainertest.agreeablebay-91c47758.centralus.azurecontainerapps.io/api/callback";
|
|
//REDIRECT_URI = "https://studymylanguage.com/api/callback";
|
|
}
|
|
|
|
//export
|
|
|
|
// let openKv = {};
|
|
// if (!isDeploy) {
|
|
// const module = await import("npm:@deno/kv");
|
|
// openKv = module.openKv;
|
|
// }
|
|
|
|
//const kv = await openKv("./mydata.db"); // Path to your local database file
|
|
|
|
// const getKv = async (isDeploy: boolean) => {
|
|
// return isDeploy && Deno.openKv ? await Deno.openKv() : await openKv(
|
|
// "https://api.deno.com/databases/35aded84-9959-4723-9906-13380079a56c/connect",
|
|
// );
|
|
// };
|
|
|
|
function keyValue(prefix: string, key: string) {
|
|
return [prefix, key]; //, Date.now(), crypto.randomUUID()];
|
|
}
|
|
|
|
// export async function setLoginEventState(
|
|
// stateId: string,
|
|
// loginState: LoginEventState,
|
|
// ) {
|
|
// await kv.set(keyValue(`LoginEventState:`, stateId), loginState);
|
|
// }
|
|
|
|
// export async function listLoginEventState() {
|
|
// const iter = kv.list({ prefix: ["LoginEventState:"] });
|
|
// //console.log("iter ", JSON.stringify(iter));
|
|
// const keys = [];
|
|
// for await (const res of iter) {
|
|
// keys.push(res);
|
|
// }
|
|
// return keys;
|
|
// }
|
|
|
|
// export async function getLoginEventState(stateId: string) {
|
|
// const result = await kv.get(keyValue(`LoginEventState:`, stateId));
|
|
// if (result && result.value) {
|
|
// return result.value as LoginEventState;
|
|
// }
|
|
// return null;
|
|
// }
|
|
|
|
export async function deleteLoginEventState(stateId: string) {
|
|
//await kv.delete(keyValue(`LoginEventState:`, stateId));
|
|
await kvStore.delete([stateId]);
|
|
}
|
|
|
|
// Function to get a list of file names in the bucket and store them in Deno KV
|
|
export async function listFilesAndStoreInKv() {
|
|
try {
|
|
// Get the files in the bucket
|
|
// const [files] = await bucket.getFiles();
|
|
//console.log("got files from bucket ", files.length);
|
|
// Extract the file names
|
|
// const fileNames = files.map((file: { name: string }) => file.name);
|
|
|
|
// await setAllBlobFileListInKv(fileNames);
|
|
} catch (error) {
|
|
console.error("Error listing files or storing in KV:", error);
|
|
throw error;
|
|
}
|
|
}
|
|
|
|
export async function setAllBlobFileListInKv(
|
|
fileNames: string[],
|
|
value?: boolean,
|
|
) {
|
|
// Store each file name in the KV database
|
|
for (const fileName of fileNames) {
|
|
// Use the file name as the key and store a simple value, such as true
|
|
//console.log("GoogleImages: ", fileName);
|
|
await kvStore.set(
|
|
keyValue(`GoogleImages:`, `${fileName}`),
|
|
value !== undefined ? value : true,
|
|
);
|
|
}
|
|
}
|
|
|
|
export async function doesBlobImageExistInKv(fileName: string) {
|
|
try {
|
|
// Construct the key used to store the file name
|
|
const key = [`GoogleImages:`, fileName];
|
|
|
|
// Retrieve the value associated with the key
|
|
const result = await kvStore.get(key);
|
|
|
|
// Check if the value exists
|
|
return result; //?.value !== null ? result.value : false;
|
|
} catch (error) {
|
|
console.error("Error checking file existence in KV:", error);
|
|
return null;
|
|
}
|
|
}
|
|
|
|
export async function getAllImageFiles() {
|
|
const iter = kvStore.list({ prefix: ["GoogleImages:"] });
|
|
//console.log("iter ", JSON.stringify(iter));
|
|
const keys = [];
|
|
for await (const res of iter) {
|
|
keys.push(res);
|
|
}
|
|
return keys;
|
|
}
|
|
|
|
export async function addBlobImageFileInKv(fileName: string) {
|
|
try {
|
|
// Construct the key used to store the file name
|
|
await kvStore.set(keyValue(`GoogleImages:`, fileName), true);
|
|
} catch (error) {
|
|
console.error("Error setting file in KV:", error);
|
|
throw error;
|
|
}
|
|
}
|
|
export async function deleteBlobImageFileInKv(fileName: string) {
|
|
try {
|
|
// Construct the key used to store the file name
|
|
await kvStore.delete(keyValue(`GoogleImages:`, fileName));
|
|
} catch (error) {
|
|
console.error("Error deleting file in KV:", error);
|
|
throw error;
|
|
}
|
|
}
|
|
|
|
// export async function getKvQuizAny(quiz_id: string): Promise<KvObj<QuizConfig>> {
|
|
// const quiz = await kv.get<QuizConfig>([`quiz:`, quiz_id]);
|
|
// if (quiz && quiz.value) {
|
|
// const quizObj = quiz.value as QuizConfig;
|
|
// return quizObj;
|
|
// } else {
|
|
// return null;
|
|
// }
|
|
// }
|
|
|
|
export async function upsertKvSessionConfigAny(
|
|
kvObjSessionConfig: KvObj<SessionConfig>,
|
|
): Promise<KvObj<SessionConfig>> {
|
|
if (
|
|
kvObjSessionConfig.key && kvObjSessionConfig.key[1] &&
|
|
kvObjSessionConfig.key[2] && kvObjSessionConfig.value
|
|
) {
|
|
try {
|
|
// if (kvObjSessionConfig.value.quiz_configs.length < 1) {
|
|
// throw new Error("WHY NO VALUE quiz_configs !!");
|
|
// }
|
|
//console.log("before",kvObjSessionConfig.value.quiz_configs.length);
|
|
await kvStore.set(
|
|
kvObjSessionConfig.key,
|
|
kvObjSessionConfig.value,
|
|
);
|
|
|
|
// Create a successful result object
|
|
const result = {
|
|
ok: true,
|
|
key: kvObjSessionConfig.key,
|
|
value: kvObjSessionConfig.value,
|
|
versionstamp: "upsertKvSessionConfigAny: success",
|
|
} as KvObj<SessionConfig>;
|
|
|
|
const clone = cloneObjectExcept(result, ["key", "value"], [
|
|
cloneObjectExcept(kvObjSessionConfig.key),
|
|
cloneObjectExcept(kvObjSessionConfig.value),
|
|
]);
|
|
//console.log("clone key",clone.key);
|
|
//console.log("after",clone.value?.quiz_configs.length);
|
|
return clone;
|
|
} catch (e) {
|
|
console.error(e);
|
|
kvObjSessionConfig.versionstamp += " upsertKvSessionConfigAny: Error: " +
|
|
e;
|
|
}
|
|
} else {
|
|
kvObjSessionConfig.versionstamp +=
|
|
" upsertKvSessionConfigAny: Input parameter bad.";
|
|
}
|
|
kvObjSessionConfig.ok = false;
|
|
return kvObjSessionConfig;
|
|
}
|
|
|
|
export async function setKvSessionConfigAny(
|
|
kvObjSessionConfig: KvObj<SessionConfig>,
|
|
): Promise<KvObj<SessionConfig>> {
|
|
if (
|
|
kvObjSessionConfig.key && kvObjSessionConfig.key[1] &&
|
|
kvObjSessionConfig.key[2] && kvObjSessionConfig.value
|
|
) {
|
|
try {
|
|
const result = await kvStore.get(kvObjSessionConfig.key);
|
|
if (result) {
|
|
// Since KvCacheStore doesn't return versionstamps, we'll skip the version check
|
|
// and always merge the data
|
|
const mergeValue = jsonMerge(
|
|
result,
|
|
kvObjSessionConfig.value,
|
|
) as SessionConfig;
|
|
|
|
// if (kvObjSessionConfig.value.quiz_configs.length < 1) {
|
|
// throw new Error("WHY NO VALUE quiz_configs !!");
|
|
// }
|
|
|
|
await kvStore.set(kvObjSessionConfig.key, mergeValue);
|
|
|
|
// Create a successful result object
|
|
const res = {
|
|
ok: true,
|
|
key: kvObjSessionConfig.key,
|
|
value: mergeValue,
|
|
versionstamp: "setKvSessionConfigAny: success",
|
|
} as KvObj<SessionConfig>;
|
|
|
|
const clone = cloneObjectExcept(res, ["key", "value"], [
|
|
cloneObjectExcept(kvObjSessionConfig.key),
|
|
mergeValue,
|
|
]);
|
|
return clone;
|
|
} else {
|
|
kvObjSessionConfig.versionstamp +=
|
|
" setKvSessionConfigAny: Database get value falure.";
|
|
}
|
|
} catch (e) {
|
|
console.error(e);
|
|
kvObjSessionConfig.versionstamp += " setKvSessionConfigAny: Error: " + e;
|
|
}
|
|
} else {
|
|
kvObjSessionConfig.versionstamp +=
|
|
" setKvSessionConfigAny: Input parameter bad.";
|
|
}
|
|
kvObjSessionConfig.ok = false;
|
|
return kvObjSessionConfig;
|
|
}
|
|
|
|
export async function getKvSessionConfig(
|
|
user_id: string,
|
|
device_id: string,
|
|
): Promise<KvObj<SessionConfig>> {
|
|
const kvObjSessionConfig = {
|
|
ok: false,
|
|
key: ["session_configs", user_id, device_id],
|
|
versionstamp: " getKvSessionConfig: Bad input parameters.",
|
|
value: null,
|
|
};
|
|
if (user_id && device_id) {
|
|
try {
|
|
const result = await kvStore.get(kvObjSessionConfig.key);
|
|
//console.log(JSON.stringify(result));
|
|
if (result) {
|
|
return {
|
|
ok: true,
|
|
key: kvObjSessionConfig.key,
|
|
value: result as SessionConfig,
|
|
versionstamp: "getKvSessionConfig: success",
|
|
} as KvObj<SessionConfig>;
|
|
} else {
|
|
kvObjSessionConfig.versionstamp =
|
|
" getKvSessionConfig: Database get value falure.";
|
|
}
|
|
} catch (e) {
|
|
console.error(e);
|
|
kvObjSessionConfig.versionstamp = " getKvSessionConfig: Error: " + e;
|
|
}
|
|
}
|
|
return kvObjSessionConfig;
|
|
}
|
|
|
|
export async function getAllKvSessionConfigs(
|
|
user_id?: string,
|
|
): Promise<KvObj<SessionConfig>[]> {
|
|
const searchPrefix = user_id
|
|
? ["session_configs", user_id]
|
|
: ["session_configs"];
|
|
const sessions: KvObj<SessionConfig>[] = [];
|
|
try {
|
|
const iter = kvStore.list({ prefix: searchPrefix }) as AsyncIterable<
|
|
{ key: Deno.KvKey; value: SessionConfig; versionstamp?: string }
|
|
>;
|
|
for await (const resEntry of iter) {
|
|
const res: KvObj<SessionConfig> = {
|
|
key: [
|
|
resEntry.key[0].toString(),
|
|
resEntry.key[1].toString(),
|
|
resEntry.key[2].toString(),
|
|
],
|
|
ok: true,
|
|
value: resEntry.value,
|
|
versionstamp: resEntry.versionstamp || "",
|
|
};
|
|
//console.log(res.key);
|
|
if (resEntry.value) {
|
|
res.ok = true;
|
|
} else {
|
|
res.ok = false;
|
|
res.versionstamp +=
|
|
" getAllKvSessionConfigs: Database get value falure.";
|
|
}
|
|
sessions.push(res);
|
|
}
|
|
} catch (e) {
|
|
console.error(e);
|
|
}
|
|
return sessions;
|
|
}
|
|
|
|
export async function deleteKvSessionConfig(
|
|
user_id: string,
|
|
device_id: string,
|
|
): Promise<KvObj<SessionConfig>> {
|
|
const kvObjSessionConfig: KvObj<SessionConfig> = {
|
|
ok: false,
|
|
key: ["session_configs", user_id, device_id],
|
|
versionstamp: " deleteKvSessionConfig: by user_id & device_id",
|
|
value: null,
|
|
};
|
|
if (user_id && device_id) {
|
|
try {
|
|
await kvStore.delete(kvObjSessionConfig.key);
|
|
kvObjSessionConfig.ok = true;
|
|
} catch (e) {
|
|
console.error(e);
|
|
kvObjSessionConfig.versionstamp = " deleteKvSessionConfig: Error: " + e;
|
|
}
|
|
} else {
|
|
kvObjSessionConfig.versionstamp =
|
|
" deleteKvSessionConfig: Input parameter bad.";
|
|
}
|
|
return kvObjSessionConfig;
|
|
}
|
|
|
|
export async function deleteKvObj<T>(kvObj: KvObj<T>): Promise<KvObj<T>> {
|
|
if (kvObj.key && kvObj.key.length > 2) {
|
|
try {
|
|
await kvStore.delete(kvObj.key);
|
|
kvObj.ok = true;
|
|
kvObj.value = null;
|
|
kvObj.versionstamp = ` deleteKvObj<T>: by ${kvObj.key[0]}, ${
|
|
kvObj.key[1]
|
|
}, ${kvObj.key[2]}`;
|
|
} catch (e) {
|
|
console.error(e);
|
|
kvObj.ok = false;
|
|
kvObj.versionstamp += " deleteKvObj<T>: Error: " + e;
|
|
}
|
|
} else {
|
|
kvObj.ok = false;
|
|
kvObj.versionstamp += " deleteKvObj<T>: Input parameter bad.";
|
|
}
|
|
return kvObj;
|
|
}
|
|
|
|
export interface UserConnection {
|
|
started_on: number;
|
|
connection_id: string;
|
|
}
|
|
|
|
export async function initUserDeviceLogin(
|
|
userId: string,
|
|
deviceId: string,
|
|
connection: UserConnection,
|
|
): Promise<KvObj<UserConnection>> {
|
|
const kvObj = {
|
|
ok: false,
|
|
key: ["user_logins:", userId, deviceId],
|
|
value: connection,
|
|
versionstamp: " initUserDeviceLogin: Input parameter bad.",
|
|
};
|
|
if (userId && deviceId && connection && connection.connection_id) {
|
|
try {
|
|
await kvStore.set(kvObj.key, connection);
|
|
|
|
// Create a successful result object
|
|
const result = {
|
|
ok: true,
|
|
key: kvObj.key,
|
|
value: connection,
|
|
versionstamp: "initUserDeviceLogin: success",
|
|
} as KvObj<UserConnection>;
|
|
|
|
const clone = cloneObjectExcept(result, ["key", "value"], [
|
|
cloneObjectExcept(kvObj.key),
|
|
cloneObjectExcept(kvObj.value),
|
|
]);
|
|
return clone;
|
|
} catch (e) {
|
|
console.error(e);
|
|
kvObj.versionstamp = " initUserDeviceLogin: Error: " + e;
|
|
}
|
|
}
|
|
return kvObj;
|
|
}
|
|
|
|
export async function deleteUserDeviceLogin(
|
|
userId: string,
|
|
deviceId: string,
|
|
): Promise<KvObj<UserConnection>> {
|
|
const kvObj: KvObj<UserConnection> = {
|
|
ok: false,
|
|
key: ["user_logins:", userId, deviceId],
|
|
value: null,
|
|
versionstamp: " deleteUserDeviceLogin: Input parameter bad.",
|
|
};
|
|
if (userId && deviceId) {
|
|
try {
|
|
await kvStore.delete(kvObj.key);
|
|
kvObj.ok = true;
|
|
kvObj.versionstamp = "1";
|
|
return kvObj;
|
|
} catch (e) {
|
|
console.error(e);
|
|
kvObj.versionstamp = " deleteUserDeviceLogin: Error: " + e;
|
|
}
|
|
}
|
|
|
|
return kvObj;
|
|
}
|
|
|
|
export async function getUserDeviceLogin(
|
|
userId: string,
|
|
deviceId: string,
|
|
): Promise<KvObj<UserConnection>> {
|
|
const kvObj: KvObj<UserConnection> = {
|
|
ok: false,
|
|
key: ["user_logins:", userId, deviceId],
|
|
versionstamp: " getUserDeviceLogin: Input parameter bad.",
|
|
value: null,
|
|
};
|
|
if (userId && deviceId) {
|
|
try {
|
|
const result = await kvStore.get(kvObj.key);
|
|
if (result) {
|
|
return {
|
|
ok: true,
|
|
key: kvObj.key,
|
|
value: result as UserConnection,
|
|
versionstamp: "getUserDeviceLogin: success",
|
|
} as KvObj<UserConnection>;
|
|
} else {
|
|
kvObj.versionstamp = " getUserDeviceLogin: Database get value falure.";
|
|
}
|
|
} catch (e) {
|
|
console.error(e);
|
|
kvObj.versionstamp = " getUserDeviceLogin: Error: " + e;
|
|
}
|
|
}
|
|
return kvObj;
|
|
}
|
|
|
|
export async function getAllUserDeviceLogin(
|
|
userId?: string,
|
|
): Promise<KvObj<UserConnection>[]> {
|
|
const searchPrefix = userId ? ["user_logins:", userId] : ["user_logins:"];
|
|
const logins: KvObj<UserConnection>[] = [];
|
|
try {
|
|
const iter = kvStore.list({ prefix: searchPrefix }) as AsyncIterable<
|
|
{ key: Deno.KvKey; value: UserConnection; versionstamp?: string }
|
|
>;
|
|
for await (const resEntry of iter) {
|
|
const res: KvObj<UserConnection> = {
|
|
key: searchPrefix,
|
|
ok: true,
|
|
value: resEntry.value,
|
|
versionstamp: resEntry.versionstamp || "",
|
|
};
|
|
if (resEntry.value) {
|
|
res.ok = true;
|
|
} else {
|
|
res.ok = false;
|
|
res.versionstamp +=
|
|
" getAllUserDeviceLogin: Database get value falure.";
|
|
}
|
|
logins.push(res);
|
|
}
|
|
} catch (e) {
|
|
console.error(e);
|
|
}
|
|
return logins;
|
|
}
|
|
|
|
export async function upsertUser(user: GoogleUser) {
|
|
if (user && user.id.length > 0) {
|
|
await kvStore.set([`users`, user.id], user);
|
|
}
|
|
}
|
|
|
|
export async function getUser(userId: string) {
|
|
const user = await kvStore.get([`users`, `${userId}`]);
|
|
return user ? user : null;
|
|
}
|
|
|
|
export async function getAllUsers() {
|
|
const iter = kvStore.list({ prefix: ["users"] });
|
|
//console.log("iter ", JSON.stringify(iter));
|
|
const keys: { key: Deno.KvKey; value: GoogleUser }[] = [];
|
|
for await (const res of iter) {
|
|
const userRes = res as { key: Deno.KvKey; value: GoogleUser };
|
|
keys.push(userRes);
|
|
}
|
|
//console.log("lists ", JSON.stringify(keys));
|
|
const users: GoogleUser[] = [];
|
|
for (const key of keys) {
|
|
const userObj = key.value as GoogleUser;
|
|
//const quiz = key.value as QuizData;// await kv.get([key.value as string]);
|
|
if (userObj) {
|
|
users.push(userObj); //.value as QuizData);
|
|
}
|
|
}
|
|
return users;
|
|
}
|
|
|
|
export async function recordTelemetry(
|
|
quiz_id: string,
|
|
userId: string,
|
|
data: Record<string, unknown>,
|
|
) {
|
|
const telemetryId = crypto.randomUUID();
|
|
await kvStore.set(keyValue(`telemetry:`, `${telemetryId}`), {
|
|
quiz_id,
|
|
user_id: userId,
|
|
data,
|
|
recorded_at: new Date().toISOString(),
|
|
});
|
|
}
|
|
|
|
export async function submitQuizResults(
|
|
quiz_id: string,
|
|
userId: string,
|
|
results: Record<string, unknown>,
|
|
) {
|
|
const resultId = crypto.randomUUID();
|
|
await kvStore.set(keyValue(`quiz_result:`, `${resultId}`), {
|
|
quiz_id,
|
|
user_id: userId,
|
|
results,
|
|
submitted_at: new Date().toISOString(),
|
|
});
|
|
}
|
|
|
|
export async function getDbToken(userId: string) {
|
|
const token = await kvStore.get([`user_tokens`, `${userId}`]);
|
|
return token ? token : null;
|
|
}
|
|
|
|
export async function upsertAccessToken(tokenResponse: AccessTokenResponse) {
|
|
await kvStore.set(
|
|
keyValue(`user_tokens`, `${tokenResponse.owner_id}`),
|
|
tokenResponse,
|
|
);
|
|
}
|