Spaces:
Running on CPU Upgrade
Running on CPU Upgrade
File size: 5,497 Bytes
dec006b | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 | import { CODE_APP_TOOLS } from "./bridgeTools";
export const CODE_APP_CALLS = [
"databases", "describe", "rows", "totals",
"addRecord", "editRecord", "editRecords", "deleteRecord",
...CODE_APP_TOOLS,
] as const;
export type BridgeCall = typeof CODE_APP_CALLS[number];
export type BridgeError = { code: string; message: string };
export type BridgeRequest = { id: string | number; call: BridgeCall; args: unknown[] };
export type BridgeAnswer = { id: string | number } & (
| { ok: true; result: unknown }
| { ok: false; error: BridgeError }
);
export type Database = { key: string; label: string };
export type BridgeField = { key: string; label?: string; type?: string };
export type DatabaseDescription = {
key: string; fields: BridgeField[]; identity: { pid: string }; recordsMutable: boolean;
};
export type RowOptions = {
filters?: unknown[]; sorts?: unknown[]; fields?: string[]; limit?: number; cursor?: string | null;
};
export type RowPage = {
fields: BridgeField[]; rows: Record<string, unknown>[]; total: number;
nextCursor: string | null; limits: unknown[];
};
export type Aggregate = ({ colId: string; agg: string } | { field: string; fn: string }) & { p?: number };
export type TotalOptions = { aggregates?: Aggregate[]; groupBy?: string | string[]; filters?: unknown[] };
export type Totals = {
total_rows: number; aggregates: Record<string, unknown>;
groups: unknown[] | null; total_groups?: number; limits: unknown[];
};
export type AddedRecord = { rid: string; pid: number };
export type EditedRecord = { pid: number; updates: Record<string, unknown> };
export interface Loopable {
databases(): Promise<Database[]>;
describe(database: string): Promise<DatabaseDescription>;
rows(database: string, options?: RowOptions): Promise<RowPage>;
totals(database: string, options?: TotalOptions): Promise<Totals>;
addRecord(database: string, values: Record<string, unknown>): Promise<AddedRecord>;
editRecord(database: string, id: string | number, values: Record<string, unknown>): Promise<EditedRecord>;
editRecords(database: string, records: { id: string | number; values: Record<string, unknown> }[]): Promise<EditedRecord[]>;
deleteRecord(database: string, id: string | number): Promise<{ ok: boolean }>;
tools: {
listBrainFiles(): Promise<unknown>;
readBrainFile(path: string): Promise<unknown>;
sendRequest(request: { to: string; title: string; body: string }): Promise<unknown>;
createSchedule(schedule: { database: string; payload: unknown; when: string }): Promise<unknown>;
};
}
// This function is serialized into the child document and must have no module dependencies.
function installLoopable() {
const host = window.parent.parent;
const pending = new Map<string, { resolve: (value: unknown) => void; reject: (error: Error) => void }>();
let sequence = 0;
const invoke = (call: string, args: unknown[]): Promise<unknown> => new Promise((resolve, reject) => {
const id = `loopable:${++sequence}`;
pending.set(id, { resolve, reject });
try {
host.postMessage({ id, call, args }, "*");
} catch {
pending.delete(id);
reject(Object.assign(new Error("This request could not be sent."), { code: "bridge_unavailable" }));
}
});
window.addEventListener("message", (event) => {
if (event.source !== host) return;
const answer = event.data;
if (!answer || typeof answer !== "object" || typeof answer.id !== "string" || typeof answer.ok !== "boolean") return;
const request = pending.get(answer.id);
if (!request) return;
if (answer.ok && Object.hasOwn(answer, "result")) {
pending.delete(answer.id);
request.resolve(answer.result);
} else if (!answer.ok && typeof answer.error?.code === "string" && typeof answer.error?.message === "string") {
pending.delete(answer.id);
request.reject(Object.assign(new Error(answer.error.message), { code: answer.error.code }));
}
});
window.addEventListener("pagehide", () => {
for (const request of pending.values()) {
request.reject(Object.assign(new Error("This App was closed."), { code: "bridge_closed" }));
}
pending.clear();
});
const loopable = {
databases: () => invoke("databases", []),
describe: (database: string) => invoke("describe", [database]),
rows: (database: string, options: RowOptions = {}) => invoke("rows", [database, options]),
totals: (database: string, options: TotalOptions = {}) => invoke("totals", [database, options]),
addRecord: (database: string, values: unknown) => invoke("addRecord", [database, values]),
editRecord: (database: string, id: unknown, values: unknown) => invoke("editRecord", [database, id, values]),
editRecords: (database: string, records: unknown) => invoke("editRecords", [database, records]),
deleteRecord: (database: string, id: unknown) => invoke("deleteRecord", [database, id]),
tools: Object.freeze({
listBrainFiles: () => invoke("tools.listBrainFiles", []),
readBrainFile: (path: string) => invoke("tools.readBrainFile", [path]),
sendRequest: (request: unknown) => invoke("tools.sendRequest", [request]),
createSchedule: (schedule: unknown) => invoke("tools.createSchedule", [schedule]),
}),
};
Object.defineProperty(window, "loopable", { value: Object.freeze(loopable), writable: false, configurable: false });
}
export function bridgeScript(): string {
return `(${installLoopable.toString()})();`.replace(/</g, "\\u003c");
}
|