149 lines
9.5 KiB
JavaScript
149 lines
9.5 KiB
JavaScript
// Legacy lifeos_states is retained as a read-only source for per-user migration.
|
|
const TABLES = { memories: "lifeos_memories", goals: "lifeos_goals", tasks: "lifeos_tasks", museum: "lifeos_favorites" };
|
|
const META = new Set(["profile", "settings", "system"]);
|
|
const empty = () => ({ profile: {}, memories: [], museum: [], settings: {}, system: { schemaVersion: 2, tasksBoard: { goals: [], tasks: [] } } });
|
|
const json = value => JSON.stringify(value);
|
|
const object = value => value && typeof value === "object" && !Array.isArray(value);
|
|
const array = value => Array.isArray(value) ? value : [];
|
|
const parse = (value, fallback) => { try { return JSON.parse(value); } catch { return fallback; } };
|
|
const date = value => typeof value === "string" && /^\d{4}-\d{2}-\d{2}$/.test(value) ? value : null;
|
|
const label = value => typeof value === "string" && value.length <= 200 ? value : null;
|
|
const cleanSystem = value => { const { tasksBoard, ...system } = object(value) ? value : {}; return { ...system, schemaVersion: 2 }; };
|
|
const response = (value, status = 200) => Response.json(value, { status, headers: { "cache-control": "no-store" } });
|
|
|
|
function entries(state) {
|
|
const system = object(state.system) ? state.system : {};
|
|
return {
|
|
profile: object(state.profile) ? state.profile : {},
|
|
settings: object(state.settings) ? state.settings : {},
|
|
system: cleanSystem(system),
|
|
memories: array(state.memories), museum: array(state.museum),
|
|
goals: array(system.tasksBoard?.goals), tasks: array(system.tasksBoard?.tasks)
|
|
};
|
|
}
|
|
|
|
function insert(db, userId, kind, value, now) {
|
|
if (META.has(kind)) return db.prepare(
|
|
"INSERT INTO lifeos_meta (user_id, kind, value_json, updated_at) VALUES (?, ?, ?, ?) ON CONFLICT DO NOTHING"
|
|
).bind(userId, kind, json(value), now);
|
|
const id = label(value?.id);
|
|
if (!id) return null;
|
|
if (kind === "memories") return db.prepare(
|
|
"INSERT INTO lifeos_memories (user_id, id, memory_date, value_json, updated_at) VALUES (?, ?, ?, ?, ?) ON CONFLICT DO NOTHING"
|
|
).bind(userId, id, date(value.date), json(value), now);
|
|
if (kind === "goals") return db.prepare(
|
|
"INSERT INTO lifeos_goals (user_id, id, target_date, done, value_json, updated_at) VALUES (?, ?, ?, ?, ?, ?) ON CONFLICT DO NOTHING"
|
|
).bind(userId, id, date(value.targetDate), Number(!!value.done), json(value), now);
|
|
if (kind === "tasks") return db.prepare(
|
|
"INSERT INTO lifeos_tasks (user_id, id, goal_id, due_date, done, value_json, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?) ON CONFLICT DO NOTHING"
|
|
).bind(userId, id, label(value.goalId), date(value.dueDate), Number(!!value.done), json(value), now);
|
|
return db.prepare(
|
|
"INSERT INTO lifeos_favorites (user_id, id, memory_id, value_json, updated_at) VALUES (?, ?, ?, ?, ?) ON CONFLICT DO NOTHING"
|
|
).bind(userId, id, label(value.memoryId), json(value), now);
|
|
}
|
|
|
|
async function seed(db, userId, state, now) {
|
|
const data = entries(state), statements = [];
|
|
for (const kind of ["profile", "settings", "system", "memories", "goals", "tasks", "museum"]) {
|
|
for (const [index, original] of (META.has(kind) ? [data[kind]] : data[kind]).entries()) {
|
|
const value = !META.has(kind) && !label(original?.id) ? { ...original, id: `legacy_${kind}_${index}` } : original;
|
|
const statement = insert(db, userId, kind, value, now);
|
|
if (statement) statements.push(statement);
|
|
}
|
|
}
|
|
// D1 batch executes a group atomically. Keep batches bounded for larger accounts.
|
|
for (let index = 0; index < statements.length; index += 50) await db.batch(statements.slice(index, index + 50));
|
|
await db.prepare("INSERT INTO lifeos_migrations (user_id, migrated_at) VALUES (?, ?) ON CONFLICT DO NOTHING").bind(userId, now).run();
|
|
}
|
|
|
|
async function migrateLegacy(db, userId) {
|
|
const marker = await db.prepare("SELECT user_id FROM lifeos_migrations WHERE user_id = ?").bind(userId).first();
|
|
if (marker) return true;
|
|
const row = await db.prepare("SELECT profile_json, memories_json, museum_json, settings_json, system_json FROM lifeos_states WHERE user_id = ?").bind(userId).first();
|
|
if (!row) return false;
|
|
const state = Object.fromEntries(["profile", "memories", "museum", "settings", "system"].map(kind =>
|
|
[kind, parse(row[`${kind}_json`], empty()[kind])]));
|
|
await seed(db, userId, state, new Date().toISOString());
|
|
return true;
|
|
}
|
|
|
|
async function read(db, userId) {
|
|
if (!await migrateLegacy(db, userId)) return { state: null, versions: null };
|
|
const [meta, memories, goals, tasks, museum] = await Promise.all([
|
|
db.prepare("SELECT kind, value_json, revision FROM lifeos_meta WHERE user_id = ?").bind(userId).all(),
|
|
...Object.values(TABLES).slice(0, 3).map(table => db.prepare(`SELECT id, value_json, revision FROM ${table} WHERE user_id = ? AND deleted_at IS NULL`).bind(userId).all()),
|
|
db.prepare("SELECT id, value_json, revision FROM lifeos_favorites WHERE user_id = ? AND deleted_at IS NULL").bind(userId).all()
|
|
]);
|
|
const state = empty(), versions = { profile: {}, settings: {}, system: {}, memories: {}, goals: {}, tasks: {}, museum: {} };
|
|
for (const row of meta.results) {
|
|
state[row.kind] = parse(row.value_json, state[row.kind]);
|
|
versions[row.kind].value = row.revision;
|
|
}
|
|
for (const [kind, rows] of Object.entries({ memories, goals, tasks, museum })) {
|
|
state[kind] = rows.results.map(row => parse(row.value_json, {}));
|
|
for (const row of rows.results) versions[kind][row.id] = row.revision;
|
|
}
|
|
state.system = { ...cleanSystem(state.system), tasksBoard: { goals: state.goals, tasks: state.tasks } };
|
|
delete state.goals; delete state.tasks;
|
|
return { state, versions };
|
|
}
|
|
|
|
async function change(db, userId, op) {
|
|
const { kind, id, value, baseVersion } = op || {};
|
|
if (!(META.has(kind) || Object.hasOwn(TABLES, kind)) || !Number.isInteger(baseVersion) || baseVersion < 0) return response({ error: "Invalid change" }, 400);
|
|
const key = META.has(kind) ? kind : label(id);
|
|
if (!key || (value !== null && (!object(value) || (!META.has(kind) && value.id !== key)))) return response({ error: "Invalid record" }, 400);
|
|
if (value !== null && json(value).length > 1_000_000) return response({ error: "Record is too large" }, 413);
|
|
if (META.has(kind) && (value === null || !object(value))) return response({ error: "Invalid metadata" }, 400);
|
|
const now = new Date().toISOString();
|
|
if (baseVersion === 0) {
|
|
if (value === null) return response({ error: "Invalid deletion" }, 400);
|
|
const result = await insert(db, userId, kind, kind === "system" ? cleanSystem(value) : value, now).run();
|
|
if (!result.meta.changes) return response({ error: "Conflict" }, 409);
|
|
return response({ ok: true, version: 1 });
|
|
}
|
|
let query, bindings;
|
|
if (META.has(kind)) {
|
|
query = "UPDATE lifeos_meta SET value_json = ?, revision = revision + 1, updated_at = ? WHERE user_id = ? AND kind = ? AND revision = ? RETURNING revision";
|
|
bindings = [json(kind === "system" ? cleanSystem(value) : value), now, userId, kind, baseVersion];
|
|
} else {
|
|
const table = TABLES[kind];
|
|
const fields = kind === "memories" ? ["memory_date"] : kind === "goals" ? ["target_date", "done"] : kind === "tasks" ? ["goal_id", "due_date", "done"] : ["memory_id"];
|
|
const columns = value === null ? [] : fields;
|
|
const extra = value === null ? [] : kind === "memories" ? [date(value.date)] :
|
|
kind === "goals" ? [date(value.targetDate), Number(!!value.done)] :
|
|
kind === "tasks" ? [label(value.goalId), date(value.dueDate), Number(!!value.done)] : [label(value.memoryId)];
|
|
query = value === null
|
|
? `UPDATE ${table} SET deleted_at = ?, updated_at = ?, revision = revision + 1 WHERE user_id = ? AND id = ? AND revision = ? AND deleted_at IS NULL RETURNING revision`
|
|
: `UPDATE ${table} SET ${columns.map(column => `${column} = ?`).join(", ")}, value_json = ?, updated_at = ?, revision = revision + 1 WHERE user_id = ? AND id = ? AND revision = ? AND deleted_at IS NULL RETURNING revision`;
|
|
bindings = value === null ? [now, now, userId, key, baseVersion] : [...extra, json(value), now, userId, key, baseVersion];
|
|
}
|
|
const updated = await db.prepare(query).bind(...bindings).first();
|
|
if (!updated) return response({ error: "Conflict" }, 409);
|
|
return response({ ok: true, version: updated.revision });
|
|
}
|
|
|
|
export async function cloudApi(request, env, userId, pathname) {
|
|
if (!userId) return response({ error: "Authentication required" }, 401);
|
|
if (!env.DB) return response({ error: "Cloud storage is unavailable" }, 503);
|
|
try {
|
|
if (pathname === "/api/lifeos-state" && request.method === "GET") return response(await read(env.DB, userId));
|
|
if (pathname === "/api/lifeos-state" && request.method === "PUT") return response({ error: "Refresh Life OS to use record-based sync" }, 426);
|
|
if (pathname === "/api/lifeos-initialize" && request.method === "POST") {
|
|
if (await migrateLegacy(env.DB, userId)) return response({ error: "Cloud account already exists" }, 409);
|
|
const { state } = await request.json();
|
|
if (!object(state) || !array(state.memories) || !array(state.museum) || !object(state.system)) return response({ error: "Invalid state" }, 400);
|
|
await seed(env.DB, userId, state, new Date().toISOString());
|
|
return response(await read(env.DB, userId));
|
|
}
|
|
if (pathname === "/api/lifeos-sync" && request.method === "POST") {
|
|
if (!await migrateLegacy(env.DB, userId)) return response({ error: "Initialize cloud account first" }, 409);
|
|
return await change(env.DB, userId, await request.json());
|
|
}
|
|
return response({ error: "Method not allowed" }, 405);
|
|
} catch (error) {
|
|
console.error("Life OS cloud operation failed", error);
|
|
return response({ error: "Cloud storage request failed" }, 500);
|
|
}
|
|
}
|