@hyper-fetch/firebase 5.0.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/.eslintrc.json +6 -0
- package/.firebaserc +5 -0
- package/README.md +73 -0
- package/database.rules.json +11 -0
- package/dist/index.cjs.js +1204 -0
- package/dist/index.cjs.js.map +7 -0
- package/dist/index.d.ts +293 -0
- package/dist/index.esm.js +1270 -0
- package/dist/index.esm.js.map +7 -0
- package/firebase.json +28 -0
- package/firestore.indexes.json +4 -0
- package/firestore.rules +8 -0
- package/package.json +75 -0
- package/src/adapter/admin/adapter.admin.sockets.ts +14 -0
- package/src/adapter/admin/adapter.admin.ts +72 -0
- package/src/adapter/admin/adapter.admin.types.ts +15 -0
- package/src/adapter/admin/index.ts +3 -0
- package/src/adapter/browser/adapter.browser.sockets.ts +18 -0
- package/src/adapter/browser/adapter.browser.ts +81 -0
- package/src/adapter/browser/adapter.browser.types.ts +15 -0
- package/src/adapter/browser/index.ts +3 -0
- package/src/adapter/index.ts +3 -0
- package/src/adapter/types/adapter.firestore.types.ts +78 -0
- package/src/adapter/types/adapter.realtime.types.ts +82 -0
- package/src/adapter/types/firestore.admin.types.ts +17 -0
- package/src/adapter/types/index.ts +4 -0
- package/src/adapter/types/realtime.admin.types.ts +17 -0
- package/src/constraints/constraints.types.ts +71 -0
- package/src/constraints/firebase.constraints.ts +117 -0
- package/src/constraints/index.ts +2 -0
- package/src/firestore/admin/firestore.admin.methods.ts +86 -0
- package/src/firestore/admin/firestore.admin.sockets.ts +86 -0
- package/src/firestore/admin/firestore.admin.utils.ts +69 -0
- package/src/firestore/admin/index.ts +2 -0
- package/src/firestore/browser/firestore.browser.methods.ts +105 -0
- package/src/firestore/browser/firestore.browser.sockets.ts +102 -0
- package/src/firestore/browser/firestore.browser.utils.ts +39 -0
- package/src/firestore/browser/index.ts +3 -0
- package/src/firestore/index.ts +3 -0
- package/src/firestore/utils/firestore.utils.ts +17 -0
- package/src/firestore/utils/index.ts +1 -0
- package/src/index.ts +5 -0
- package/src/realtime/admin/index.ts +2 -0
- package/src/realtime/admin/realtime.admin.methods.ts +74 -0
- package/src/realtime/admin/realtime.admin.sockets.ts +93 -0
- package/src/realtime/admin/realtime.admin.utils.ts +54 -0
- package/src/realtime/browser/index.ts +3 -0
- package/src/realtime/browser/realtime.browser.methods.ts +78 -0
- package/src/realtime/browser/realtime.browser.sockets.ts +96 -0
- package/src/realtime/browser/realtime.browser.utils.ts +59 -0
- package/src/realtime/index.ts +3 -0
- package/src/realtime/utils/index.ts +1 -0
- package/src/realtime/utils/realtime.utils.ts +7 -0
- package/src/utils/cache.utils.ts +33 -0
- package/src/utils/index.ts +2 -0
- package/src/utils/misc.ts +10 -0
- package/test.sh +3 -0
- package/tsconfig.json +8 -0
|
@@ -0,0 +1,102 @@
|
|
|
1
|
+
import { getSocketAdapterBindings } from "@hyper-fetch/sockets";
|
|
2
|
+
import { onSnapshot, Firestore, doc, query, collection, disableNetwork, enableNetwork } from "firebase/firestore";
|
|
3
|
+
|
|
4
|
+
import { getStatus, isDocOrQuery } from "utils";
|
|
5
|
+
import { mapConstraint, getGroupedResultFirestore, getOrderedResultFirestore } from "firestore";
|
|
6
|
+
import { FirestoreSocketAdapterType } from "adapter";
|
|
7
|
+
|
|
8
|
+
export const firestoreSockets = (database: Firestore): FirestoreSocketAdapterType => {
|
|
9
|
+
return (socket) => {
|
|
10
|
+
const {
|
|
11
|
+
open,
|
|
12
|
+
connecting,
|
|
13
|
+
reconnectionAttempts,
|
|
14
|
+
listeners,
|
|
15
|
+
removeListener,
|
|
16
|
+
onConnect,
|
|
17
|
+
onReconnect,
|
|
18
|
+
onDisconnect,
|
|
19
|
+
onListen,
|
|
20
|
+
onOpen,
|
|
21
|
+
onClose,
|
|
22
|
+
onEvent,
|
|
23
|
+
onError,
|
|
24
|
+
} = getSocketAdapterBindings(socket, { open: true });
|
|
25
|
+
|
|
26
|
+
const connect = () => {
|
|
27
|
+
const enabled = onConnect();
|
|
28
|
+
|
|
29
|
+
if (enabled) {
|
|
30
|
+
enableNetwork(database);
|
|
31
|
+
onOpen();
|
|
32
|
+
}
|
|
33
|
+
};
|
|
34
|
+
|
|
35
|
+
const disconnect = () => {
|
|
36
|
+
disableNetwork(database);
|
|
37
|
+
onDisconnect();
|
|
38
|
+
onClose();
|
|
39
|
+
};
|
|
40
|
+
|
|
41
|
+
const reconnect = () => {
|
|
42
|
+
onReconnect(disconnect, connect);
|
|
43
|
+
};
|
|
44
|
+
|
|
45
|
+
const listen: ReturnType<FirestoreSocketAdapterType>["listen"] = (listener, callback) => {
|
|
46
|
+
const fullUrl = socket.url + listener.endpoint;
|
|
47
|
+
const { options } = listener;
|
|
48
|
+
|
|
49
|
+
let path;
|
|
50
|
+
const queryType = isDocOrQuery(fullUrl);
|
|
51
|
+
if (queryType === "doc") {
|
|
52
|
+
path = doc(database, fullUrl);
|
|
53
|
+
} else {
|
|
54
|
+
const constraints = options?.constraints || [];
|
|
55
|
+
const queryConstraints = constraints.map((constr) => mapConstraint(constr)) || [];
|
|
56
|
+
path = query(collection(database, fullUrl), ...queryConstraints);
|
|
57
|
+
}
|
|
58
|
+
let unsubscribe = () => {};
|
|
59
|
+
let unmount = () => {};
|
|
60
|
+
let clearListeners = () => {};
|
|
61
|
+
|
|
62
|
+
unsubscribe = onSnapshot(
|
|
63
|
+
path,
|
|
64
|
+
(snapshot) => {
|
|
65
|
+
const response = queryType === "doc" ? snapshot.data() || null : getOrderedResultFirestore(snapshot);
|
|
66
|
+
const status = getStatus(response);
|
|
67
|
+
const groupedResult = options?.groupByChangeType === true ? getGroupedResultFirestore(snapshot) : null;
|
|
68
|
+
const extra = { ref: path, snapshot, groupedResult, status };
|
|
69
|
+
callback({ data: response, extra });
|
|
70
|
+
onEvent(listener.endpoint, response, extra);
|
|
71
|
+
},
|
|
72
|
+
(error) => {
|
|
73
|
+
onError(error);
|
|
74
|
+
},
|
|
75
|
+
);
|
|
76
|
+
unmount = onListen(listener, callback, unsubscribe);
|
|
77
|
+
clearListeners = () => {
|
|
78
|
+
unsubscribe();
|
|
79
|
+
unmount();
|
|
80
|
+
};
|
|
81
|
+
|
|
82
|
+
return clearListeners;
|
|
83
|
+
};
|
|
84
|
+
|
|
85
|
+
const emit = async () => {
|
|
86
|
+
throw new Error("Cannot emit from Firestore database socket.");
|
|
87
|
+
};
|
|
88
|
+
|
|
89
|
+
return {
|
|
90
|
+
open,
|
|
91
|
+
reconnectionAttempts,
|
|
92
|
+
listeners,
|
|
93
|
+
connecting,
|
|
94
|
+
listen,
|
|
95
|
+
removeListener,
|
|
96
|
+
emit,
|
|
97
|
+
connect,
|
|
98
|
+
reconnect,
|
|
99
|
+
disconnect,
|
|
100
|
+
};
|
|
101
|
+
};
|
|
102
|
+
};
|
|
@@ -0,0 +1,39 @@
|
|
|
1
|
+
import { endAt, endBefore, limit, orderBy, startAfter, startAt, where } from "firebase/firestore";
|
|
2
|
+
import { OrderByDirection } from "@firebase/firestore";
|
|
3
|
+
|
|
4
|
+
import { FirestorePermittedMethods, FirestoreQueryConstraints, SharedQueryConstraints } from "constraints";
|
|
5
|
+
|
|
6
|
+
export const mapConstraint = ({ type, values }: FirestorePermittedMethods) => {
|
|
7
|
+
switch (type) {
|
|
8
|
+
case FirestoreQueryConstraints.WHERE: {
|
|
9
|
+
const [fieldPath, strOp, value] = values;
|
|
10
|
+
return where(fieldPath, strOp, value);
|
|
11
|
+
}
|
|
12
|
+
case FirestoreQueryConstraints.ORDER_BY: {
|
|
13
|
+
const [field, ord] = values;
|
|
14
|
+
return orderBy(field, ord as OrderByDirection);
|
|
15
|
+
}
|
|
16
|
+
case FirestoreQueryConstraints.LIMIT: {
|
|
17
|
+
const [limitValue] = values;
|
|
18
|
+
return limit(limitValue);
|
|
19
|
+
}
|
|
20
|
+
case SharedQueryConstraints.START_AT: {
|
|
21
|
+
const [docOrFields] = values;
|
|
22
|
+
return startAt(docOrFields);
|
|
23
|
+
}
|
|
24
|
+
case SharedQueryConstraints.START_AFTER: {
|
|
25
|
+
const [docOrFields] = values;
|
|
26
|
+
return startAfter(docOrFields);
|
|
27
|
+
}
|
|
28
|
+
case SharedQueryConstraints.END_AT: {
|
|
29
|
+
const [docOrFields] = values;
|
|
30
|
+
return endAt(docOrFields);
|
|
31
|
+
}
|
|
32
|
+
case SharedQueryConstraints.END_BEFORE: {
|
|
33
|
+
const [docOrFields] = values;
|
|
34
|
+
return endBefore(docOrFields);
|
|
35
|
+
}
|
|
36
|
+
default:
|
|
37
|
+
throw new Error(`Unknown method ${type}`);
|
|
38
|
+
}
|
|
39
|
+
};
|
|
@@ -0,0 +1,17 @@
|
|
|
1
|
+
export const getOrderedResultFirestore = (snapshot: any) => {
|
|
2
|
+
const result = [];
|
|
3
|
+
snapshot.docs.forEach((d) => {
|
|
4
|
+
result.push(d.data());
|
|
5
|
+
});
|
|
6
|
+
return result.length > 0 ? result : null;
|
|
7
|
+
};
|
|
8
|
+
|
|
9
|
+
export const getGroupedResultFirestore = (snapshot: any) => {
|
|
10
|
+
const groupedResult = { added: [], modified: [], removed: [] };
|
|
11
|
+
snapshot.docChanges().forEach((change) => {
|
|
12
|
+
groupedResult[change.type].push(change.doc.data());
|
|
13
|
+
});
|
|
14
|
+
return [...groupedResult.added, ...groupedResult.modified, ...groupedResult.removed].length > 0
|
|
15
|
+
? groupedResult
|
|
16
|
+
: null;
|
|
17
|
+
};
|
|
@@ -0,0 +1 @@
|
|
|
1
|
+
export * from "./firestore.utils";
|
package/src/index.ts
ADDED
|
@@ -0,0 +1,74 @@
|
|
|
1
|
+
import { Database } from "firebase-admin/database";
|
|
2
|
+
import { RequestInstance } from "@hyper-fetch/core";
|
|
3
|
+
|
|
4
|
+
import { RealtimeDBMethodsUnion } from "adapter/types";
|
|
5
|
+
import { getStatus, isDocOrQuery } from "utils";
|
|
6
|
+
import { applyRealtimeAdminConstraints, getOrderedResultRealtime } from "realtime";
|
|
7
|
+
import {
|
|
8
|
+
PermittedConstraints,
|
|
9
|
+
RealtimeConstraintsUnion,
|
|
10
|
+
RealtimePermittedMethods,
|
|
11
|
+
SharedQueryConstraints,
|
|
12
|
+
} from "constraints";
|
|
13
|
+
|
|
14
|
+
export const getRealtimeDbAdminMethods = <R extends RequestInstance>(
|
|
15
|
+
request: R,
|
|
16
|
+
database: Database,
|
|
17
|
+
url: string,
|
|
18
|
+
onSuccess,
|
|
19
|
+
onError,
|
|
20
|
+
resolve,
|
|
21
|
+
events: { onRequestStart; onResponseEnd; onResponseStart; onRequestEnd },
|
|
22
|
+
): ((
|
|
23
|
+
methodName: RealtimeDBMethodsUnion,
|
|
24
|
+
data: {
|
|
25
|
+
constraints: PermittedConstraints<RealtimePermittedMethods, RealtimeConstraintsUnion | SharedQueryConstraints>[];
|
|
26
|
+
data: any;
|
|
27
|
+
options: Record<string, any>;
|
|
28
|
+
},
|
|
29
|
+
) => Promise<void>) => {
|
|
30
|
+
const [fullUrl] = url.split("?");
|
|
31
|
+
const path = database.ref(fullUrl);
|
|
32
|
+
const methods = {
|
|
33
|
+
get: async ({ constraints }) => {
|
|
34
|
+
const docOrQuery = isDocOrQuery(fullUrl);
|
|
35
|
+
const q = applyRealtimeAdminConstraints(path, constraints);
|
|
36
|
+
const snapshot = await q.get();
|
|
37
|
+
const res = docOrQuery === "doc" ? snapshot.val() : getOrderedResultRealtime(snapshot);
|
|
38
|
+
const status = getStatus(res);
|
|
39
|
+
return { result: res, status, extra: { ref: path, snapshot } };
|
|
40
|
+
},
|
|
41
|
+
set: async ({ data }) => {
|
|
42
|
+
await path.set(data);
|
|
43
|
+
return { result: data, status: "success", extra: { ref: path } };
|
|
44
|
+
},
|
|
45
|
+
push: async ({ data }) => {
|
|
46
|
+
const resRef = await path.push(data);
|
|
47
|
+
return { result: data, status: "success", extra: { ref: resRef, key: resRef.key } };
|
|
48
|
+
},
|
|
49
|
+
update: async ({ data }) => {
|
|
50
|
+
await path.update(data);
|
|
51
|
+
return { result: data, status: "success", extra: { ref: path } };
|
|
52
|
+
},
|
|
53
|
+
remove: async () => {
|
|
54
|
+
await path.remove();
|
|
55
|
+
return { result: null, status: "success", extra: { ref: path } };
|
|
56
|
+
},
|
|
57
|
+
};
|
|
58
|
+
|
|
59
|
+
return async (methodName: RealtimeDBMethodsUnion, data) => {
|
|
60
|
+
try {
|
|
61
|
+
events.onRequestStart();
|
|
62
|
+
const { result, status, extra } = await methods[methodName](data);
|
|
63
|
+
events.onRequestEnd();
|
|
64
|
+
events.onResponseStart();
|
|
65
|
+
onSuccess(result, status, extra, resolve);
|
|
66
|
+
events.onResponseEnd();
|
|
67
|
+
} catch (e) {
|
|
68
|
+
events.onRequestEnd();
|
|
69
|
+
events.onResponseStart();
|
|
70
|
+
onError(e, "error", {}, resolve);
|
|
71
|
+
events.onResponseEnd();
|
|
72
|
+
}
|
|
73
|
+
};
|
|
74
|
+
};
|
|
@@ -0,0 +1,93 @@
|
|
|
1
|
+
import { Database } from "firebase-admin/lib/database";
|
|
2
|
+
import { getSocketAdapterBindings } from "@hyper-fetch/sockets";
|
|
3
|
+
|
|
4
|
+
import { applyRealtimeAdminConstraints, getOrderedResultRealtime } from "realtime";
|
|
5
|
+
import { getStatus, isDocOrQuery } from "utils";
|
|
6
|
+
import { RealtimeAdminOnValueMethodExtra, RealtimeAdminSocketAdapterType } from "adapter";
|
|
7
|
+
|
|
8
|
+
export const realtimeSocketsAdmin = (database: Database): RealtimeAdminSocketAdapterType => {
|
|
9
|
+
return (socket) => {
|
|
10
|
+
const {
|
|
11
|
+
open,
|
|
12
|
+
connecting,
|
|
13
|
+
reconnectionAttempts,
|
|
14
|
+
listeners,
|
|
15
|
+
removeListener,
|
|
16
|
+
onConnect,
|
|
17
|
+
onReconnect,
|
|
18
|
+
onDisconnect,
|
|
19
|
+
onListen,
|
|
20
|
+
onOpen,
|
|
21
|
+
onClose,
|
|
22
|
+
onEvent,
|
|
23
|
+
onError,
|
|
24
|
+
} = getSocketAdapterBindings(socket, { open: true });
|
|
25
|
+
|
|
26
|
+
const connect = () => {
|
|
27
|
+
const enabled = onConnect();
|
|
28
|
+
|
|
29
|
+
if (enabled) {
|
|
30
|
+
database.goOnline();
|
|
31
|
+
onOpen();
|
|
32
|
+
}
|
|
33
|
+
};
|
|
34
|
+
|
|
35
|
+
const disconnect = () => {
|
|
36
|
+
database.goOffline();
|
|
37
|
+
onDisconnect();
|
|
38
|
+
onClose();
|
|
39
|
+
};
|
|
40
|
+
|
|
41
|
+
const reconnect = () => {
|
|
42
|
+
onReconnect(disconnect, connect);
|
|
43
|
+
};
|
|
44
|
+
|
|
45
|
+
const listen: ReturnType<RealtimeAdminSocketAdapterType>["listen"] = (listener, callback) => {
|
|
46
|
+
const fullUrl = socket.url + listener.endpoint;
|
|
47
|
+
const path = database.ref(fullUrl);
|
|
48
|
+
const { options } = listener;
|
|
49
|
+
const onlyOnce = options?.onlyOnce || false;
|
|
50
|
+
const q = applyRealtimeAdminConstraints(path, options?.constraints || []);
|
|
51
|
+
const method = onlyOnce === true ? "once" : "on";
|
|
52
|
+
q[method](
|
|
53
|
+
"value",
|
|
54
|
+
(snapshot) => {
|
|
55
|
+
const response = isDocOrQuery(fullUrl) === "doc" ? snapshot.val() : getOrderedResultRealtime(snapshot);
|
|
56
|
+
const status = getStatus(response);
|
|
57
|
+
const extra: RealtimeAdminOnValueMethodExtra = { ref: path, snapshot, status };
|
|
58
|
+
callback({ data: response, extra });
|
|
59
|
+
onEvent(listener.endpoint, response, extra);
|
|
60
|
+
},
|
|
61
|
+
(error) => {
|
|
62
|
+
onError(error);
|
|
63
|
+
},
|
|
64
|
+
);
|
|
65
|
+
const unsubscribe = () => q.off("value");
|
|
66
|
+
const unmount = onListen(listener, callback, unsubscribe);
|
|
67
|
+
|
|
68
|
+
const clearListeners = () => {
|
|
69
|
+
unsubscribe();
|
|
70
|
+
unmount();
|
|
71
|
+
};
|
|
72
|
+
|
|
73
|
+
return clearListeners;
|
|
74
|
+
};
|
|
75
|
+
|
|
76
|
+
const emit = async () => {
|
|
77
|
+
throw new Error("Cannot emit from Realtime database socket.");
|
|
78
|
+
};
|
|
79
|
+
|
|
80
|
+
return {
|
|
81
|
+
open,
|
|
82
|
+
reconnectionAttempts,
|
|
83
|
+
listeners,
|
|
84
|
+
connecting,
|
|
85
|
+
listen,
|
|
86
|
+
removeListener,
|
|
87
|
+
emit,
|
|
88
|
+
connect,
|
|
89
|
+
reconnect,
|
|
90
|
+
disconnect,
|
|
91
|
+
};
|
|
92
|
+
};
|
|
93
|
+
};
|
|
@@ -0,0 +1,54 @@
|
|
|
1
|
+
import { Reference } from "firebase-admin/lib/database";
|
|
2
|
+
|
|
3
|
+
import { RealtimePermittedMethods, RealtimeQueryConstraints, SharedQueryConstraints } from "constraints";
|
|
4
|
+
|
|
5
|
+
export const applyRealtimeAdminConstraint = (ref: Reference, { type, values }: RealtimePermittedMethods) => {
|
|
6
|
+
switch (type) {
|
|
7
|
+
case RealtimeQueryConstraints.ORDER_BY_CHILD: {
|
|
8
|
+
const [value] = values;
|
|
9
|
+
return ref.orderByChild(value);
|
|
10
|
+
}
|
|
11
|
+
case RealtimeQueryConstraints.ORDER_BY_KEY: {
|
|
12
|
+
return ref.orderByKey();
|
|
13
|
+
}
|
|
14
|
+
case RealtimeQueryConstraints.ORDER_BY_VALUE: {
|
|
15
|
+
return ref.orderByValue();
|
|
16
|
+
}
|
|
17
|
+
case SharedQueryConstraints.START_AT: {
|
|
18
|
+
const [[value]] = values;
|
|
19
|
+
return ref.startAt(value);
|
|
20
|
+
}
|
|
21
|
+
case SharedQueryConstraints.START_AFTER: {
|
|
22
|
+
const [[value]] = values;
|
|
23
|
+
return ref.startAfter(value);
|
|
24
|
+
}
|
|
25
|
+
case SharedQueryConstraints.END_AT: {
|
|
26
|
+
const [[value]] = values;
|
|
27
|
+
return ref.endAt(value);
|
|
28
|
+
}
|
|
29
|
+
case SharedQueryConstraints.END_BEFORE: {
|
|
30
|
+
const [[value]] = values;
|
|
31
|
+
return ref.endBefore(value);
|
|
32
|
+
}
|
|
33
|
+
case RealtimeQueryConstraints.LIMIT_TO_FIRST: {
|
|
34
|
+
const [value] = values;
|
|
35
|
+
return ref.limitToFirst(value);
|
|
36
|
+
}
|
|
37
|
+
case RealtimeQueryConstraints.LIMIT_TO_LAST: {
|
|
38
|
+
const [value] = values;
|
|
39
|
+
return ref.limitToLast(value);
|
|
40
|
+
}
|
|
41
|
+
case RealtimeQueryConstraints.EQUAL_TO: {
|
|
42
|
+
const [value] = values;
|
|
43
|
+
return ref.equalTo(value);
|
|
44
|
+
}
|
|
45
|
+
default:
|
|
46
|
+
throw new Error(`Unknown method ${type}`);
|
|
47
|
+
}
|
|
48
|
+
};
|
|
49
|
+
|
|
50
|
+
export const applyRealtimeAdminConstraints = (ref: Reference, constraints: RealtimePermittedMethods[]) => {
|
|
51
|
+
return constraints.reduce((collection, constraint) => {
|
|
52
|
+
return applyRealtimeAdminConstraint(collection, constraint);
|
|
53
|
+
}, ref);
|
|
54
|
+
};
|
|
@@ -0,0 +1,78 @@
|
|
|
1
|
+
import { Database, get, push, query, ref, remove, set, update } from "firebase/database";
|
|
2
|
+
import { RequestInstance } from "@hyper-fetch/core";
|
|
3
|
+
|
|
4
|
+
import { RealtimeDBMethodsUnion } from "adapter/types";
|
|
5
|
+
import { mapRealtimeConstraint, getOrderedResultRealtime } from "realtime";
|
|
6
|
+
import { getStatus, isDocOrQuery } from "utils";
|
|
7
|
+
import {
|
|
8
|
+
PermittedConstraints,
|
|
9
|
+
RealtimeConstraintsUnion,
|
|
10
|
+
RealtimePermittedMethods,
|
|
11
|
+
SharedQueryConstraints,
|
|
12
|
+
} from "constraints";
|
|
13
|
+
|
|
14
|
+
export const getRealtimeDbBrowserMethods = <R extends RequestInstance>(
|
|
15
|
+
request: R,
|
|
16
|
+
database: Database,
|
|
17
|
+
url: string,
|
|
18
|
+
onSuccess,
|
|
19
|
+
onError,
|
|
20
|
+
resolve,
|
|
21
|
+
events: { onResponseStart; onRequestStart; onRequestEnd; onResponseEnd },
|
|
22
|
+
): ((
|
|
23
|
+
methodName: RealtimeDBMethodsUnion,
|
|
24
|
+
data: {
|
|
25
|
+
constraints: PermittedConstraints<RealtimePermittedMethods, RealtimeConstraintsUnion | SharedQueryConstraints>[];
|
|
26
|
+
data: any;
|
|
27
|
+
options: Record<string, any>;
|
|
28
|
+
},
|
|
29
|
+
) => Promise<void>) => {
|
|
30
|
+
const [fullUrl] = url.split("?");
|
|
31
|
+
const path = ref(database, fullUrl);
|
|
32
|
+
const methods = {
|
|
33
|
+
get: async ({
|
|
34
|
+
constraints = [],
|
|
35
|
+
}: {
|
|
36
|
+
constraints?: PermittedConstraints<RealtimePermittedMethods, RealtimeConstraintsUnion | SharedQueryConstraints>[];
|
|
37
|
+
}) => {
|
|
38
|
+
const params = constraints.map((constraint) => mapRealtimeConstraint(constraint));
|
|
39
|
+
const q = query(path, ...params);
|
|
40
|
+
const snapshot = await get(q);
|
|
41
|
+
const res = isDocOrQuery(fullUrl) === "doc" ? snapshot.val() : getOrderedResultRealtime(snapshot);
|
|
42
|
+
const status = getStatus(res);
|
|
43
|
+
return { result: res, status, extra: { ref: path, snapshot } };
|
|
44
|
+
},
|
|
45
|
+
set: async ({ data }: { data?: any }) => {
|
|
46
|
+
await set(path, data);
|
|
47
|
+
return { result: data, status: "success", extra: { ref: path } };
|
|
48
|
+
},
|
|
49
|
+
push: async ({ data }: { data?: any }) => {
|
|
50
|
+
const resRef = await push(path, data);
|
|
51
|
+
return { result: data, status: "success", extra: { ref: resRef, key: resRef.key } };
|
|
52
|
+
},
|
|
53
|
+
update: async ({ data }: { data?: any }) => {
|
|
54
|
+
await update(path, data);
|
|
55
|
+
return { result: data, status: "success", extra: { ref: path } };
|
|
56
|
+
},
|
|
57
|
+
remove: async () => {
|
|
58
|
+
await remove(path);
|
|
59
|
+
return { result: null, status: "success", extra: { ref: path } };
|
|
60
|
+
},
|
|
61
|
+
};
|
|
62
|
+
|
|
63
|
+
return async (methodName: RealtimeDBMethodsUnion, data) => {
|
|
64
|
+
try {
|
|
65
|
+
events.onRequestStart();
|
|
66
|
+
const { result, status, extra } = await methods[methodName](data);
|
|
67
|
+
events.onRequestEnd();
|
|
68
|
+
events.onResponseStart();
|
|
69
|
+
onSuccess(result, status, extra, resolve);
|
|
70
|
+
events.onResponseEnd();
|
|
71
|
+
} catch (e) {
|
|
72
|
+
events.onRequestEnd();
|
|
73
|
+
events.onResponseStart();
|
|
74
|
+
onError(e, "error", {}, resolve);
|
|
75
|
+
events.onResponseEnd();
|
|
76
|
+
}
|
|
77
|
+
};
|
|
78
|
+
};
|
|
@@ -0,0 +1,96 @@
|
|
|
1
|
+
import { getSocketAdapterBindings } from "@hyper-fetch/sockets";
|
|
2
|
+
import { onValue, query, Database, ref, goOffline, goOnline } from "firebase/database";
|
|
3
|
+
|
|
4
|
+
import { getOrderedResultRealtime, mapRealtimeConstraint } from "realtime";
|
|
5
|
+
import { getStatus, isDocOrQuery } from "utils";
|
|
6
|
+
import { RealtimeSocketAdapterType } from "adapter";
|
|
7
|
+
|
|
8
|
+
export const realtimeSockets = (database: Database): RealtimeSocketAdapterType => {
|
|
9
|
+
return (socket) => {
|
|
10
|
+
const {
|
|
11
|
+
open,
|
|
12
|
+
connecting,
|
|
13
|
+
reconnectionAttempts,
|
|
14
|
+
listeners,
|
|
15
|
+
removeListener,
|
|
16
|
+
onConnect,
|
|
17
|
+
onReconnect,
|
|
18
|
+
onDisconnect,
|
|
19
|
+
onListen,
|
|
20
|
+
onOpen,
|
|
21
|
+
onClose,
|
|
22
|
+
onEvent,
|
|
23
|
+
onError,
|
|
24
|
+
} = getSocketAdapterBindings(socket, { open: true });
|
|
25
|
+
|
|
26
|
+
const connect = () => {
|
|
27
|
+
const enabled = onConnect();
|
|
28
|
+
|
|
29
|
+
if (enabled) {
|
|
30
|
+
goOnline(database);
|
|
31
|
+
onOpen();
|
|
32
|
+
}
|
|
33
|
+
};
|
|
34
|
+
|
|
35
|
+
const disconnect = () => {
|
|
36
|
+
goOffline(database);
|
|
37
|
+
onDisconnect();
|
|
38
|
+
onClose();
|
|
39
|
+
};
|
|
40
|
+
|
|
41
|
+
const reconnect = () => {
|
|
42
|
+
onReconnect(disconnect, connect);
|
|
43
|
+
};
|
|
44
|
+
|
|
45
|
+
const listen: ReturnType<RealtimeSocketAdapterType>["listen"] = (listener, callback) => {
|
|
46
|
+
const fullUrl = socket.url + listener.endpoint;
|
|
47
|
+
const path = ref(database, fullUrl);
|
|
48
|
+
|
|
49
|
+
const { options } = listener;
|
|
50
|
+
const onlyOnce = options?.onlyOnce || false;
|
|
51
|
+
const params = options?.constraints?.map((constraint) => mapRealtimeConstraint(constraint)) || [];
|
|
52
|
+
const queryConstraints = query(path, ...params);
|
|
53
|
+
let unsubscribe = () => {};
|
|
54
|
+
let unmount = () => {};
|
|
55
|
+
let clearListeners = () => {};
|
|
56
|
+
unsubscribe = onValue(
|
|
57
|
+
queryConstraints,
|
|
58
|
+
(snapshot) => {
|
|
59
|
+
const response = isDocOrQuery(fullUrl) === "doc" ? snapshot.val() : getOrderedResultRealtime(snapshot);
|
|
60
|
+
const status = getStatus(response);
|
|
61
|
+
const extra = { ref: path, snapshot, status };
|
|
62
|
+
callback({ data: response, extra });
|
|
63
|
+
onEvent(listener.endpoint, response, extra);
|
|
64
|
+
},
|
|
65
|
+
(error) => {
|
|
66
|
+
onError(error);
|
|
67
|
+
},
|
|
68
|
+
{ onlyOnce },
|
|
69
|
+
);
|
|
70
|
+
unmount = onListen(listener, callback, unsubscribe);
|
|
71
|
+
clearListeners = () => {
|
|
72
|
+
unsubscribe();
|
|
73
|
+
unmount();
|
|
74
|
+
};
|
|
75
|
+
|
|
76
|
+
return clearListeners;
|
|
77
|
+
};
|
|
78
|
+
|
|
79
|
+
const emit = async () => {
|
|
80
|
+
throw new Error("Cannot emit from Realtime database socket.");
|
|
81
|
+
};
|
|
82
|
+
|
|
83
|
+
return {
|
|
84
|
+
open,
|
|
85
|
+
reconnectionAttempts,
|
|
86
|
+
listeners,
|
|
87
|
+
connecting,
|
|
88
|
+
listen,
|
|
89
|
+
removeListener,
|
|
90
|
+
emit,
|
|
91
|
+
connect,
|
|
92
|
+
reconnect,
|
|
93
|
+
disconnect,
|
|
94
|
+
};
|
|
95
|
+
};
|
|
96
|
+
};
|
|
@@ -0,0 +1,59 @@
|
|
|
1
|
+
import {
|
|
2
|
+
endAt,
|
|
3
|
+
endBefore,
|
|
4
|
+
equalTo,
|
|
5
|
+
limitToFirst,
|
|
6
|
+
limitToLast,
|
|
7
|
+
orderByChild,
|
|
8
|
+
orderByKey,
|
|
9
|
+
orderByValue,
|
|
10
|
+
startAfter,
|
|
11
|
+
startAt,
|
|
12
|
+
} from "firebase/database";
|
|
13
|
+
|
|
14
|
+
import { RealtimePermittedMethods, RealtimeQueryConstraints, SharedQueryConstraints } from "constraints";
|
|
15
|
+
|
|
16
|
+
export const mapRealtimeConstraint = ({ type, values }: RealtimePermittedMethods) => {
|
|
17
|
+
switch (type) {
|
|
18
|
+
case RealtimeQueryConstraints.ORDER_BY_CHILD: {
|
|
19
|
+
const [value] = values;
|
|
20
|
+
return orderByChild(value);
|
|
21
|
+
}
|
|
22
|
+
case RealtimeQueryConstraints.ORDER_BY_KEY: {
|
|
23
|
+
return orderByKey();
|
|
24
|
+
}
|
|
25
|
+
case RealtimeQueryConstraints.ORDER_BY_VALUE: {
|
|
26
|
+
return orderByValue();
|
|
27
|
+
}
|
|
28
|
+
case SharedQueryConstraints.START_AT: {
|
|
29
|
+
const [[value]] = values;
|
|
30
|
+
return startAt(value);
|
|
31
|
+
}
|
|
32
|
+
case SharedQueryConstraints.START_AFTER: {
|
|
33
|
+
const [[value]] = values;
|
|
34
|
+
return startAfter(value);
|
|
35
|
+
}
|
|
36
|
+
case SharedQueryConstraints.END_AT: {
|
|
37
|
+
const [[value]] = values;
|
|
38
|
+
return endAt(value);
|
|
39
|
+
}
|
|
40
|
+
case SharedQueryConstraints.END_BEFORE: {
|
|
41
|
+
const [[value]] = values;
|
|
42
|
+
return endBefore(value);
|
|
43
|
+
}
|
|
44
|
+
case RealtimeQueryConstraints.LIMIT_TO_FIRST: {
|
|
45
|
+
const [value] = values;
|
|
46
|
+
return limitToFirst(value);
|
|
47
|
+
}
|
|
48
|
+
case RealtimeQueryConstraints.LIMIT_TO_LAST: {
|
|
49
|
+
const [value] = values;
|
|
50
|
+
return limitToLast(value);
|
|
51
|
+
}
|
|
52
|
+
case RealtimeQueryConstraints.EQUAL_TO: {
|
|
53
|
+
const [value] = values;
|
|
54
|
+
return equalTo(value);
|
|
55
|
+
}
|
|
56
|
+
default:
|
|
57
|
+
throw new Error(`Unknown method ${type}`);
|
|
58
|
+
}
|
|
59
|
+
};
|
|
@@ -0,0 +1 @@
|
|
|
1
|
+
export * from "./realtime.utils";
|