@lowdefy/shell 3.23.2 → 7.2.0

package/src/auth/signInWithSheet.test.js

@@ -0,0 +1,205 @@
+/*
+  Copyright 2020-2026 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/
+
+import { createHash } from 'node:crypto';
+import { jest } from '@jest/globals';
+import { Platform } from 'react-native';
+
+import getSheetReturnUrl from './getSheetReturnUrl.js';
+import isSheetReturnLink from './isSheetReturnLink.js';
+import parseQuery from './parseQuery.js';
+import signInWithSheet from './signInWithSheet.js';
+
+jest.mock('expo-crypto', () => {
+  const nodeCrypto = jest.requireActual('node:crypto');
+  return {
+    CryptoDigestAlgorithm: { SHA256: 'SHA-256' },
+    digest: jest.fn(async (algorithm, data) =>
+      nodeCrypto.createHash('sha256').update(data).digest()
+    ),
+    getRandomBytes: jest.fn((count) => new Uint8Array(nodeCrypto.randomBytes(count))),
+    randomUUID: jest.fn(() => 'state-1'),
+  };
+});
+
+jest.mock('expo-web-browser', () => ({ openAuthSessionAsync: jest.fn() }));
+
+const WebBrowser = jest.requireMock('expo-web-browser');
+
+const apiBase = 'https://field.example.com';
+const shell = { id: 'field', scheme: 'com.example.field' };
+
+function base64Url(buffer) {
+  return Buffer.from(buffer).toString('base64url');
+}
+
+function createAuthApi() {
+  return { exchangeToken: jest.fn(async () => ({ status: 'signedIn' })) };
+}
+
+afterEach(() => {
+  jest.restoreAllMocks();
+});
+
+function onAndroid() {
+  jest.replaceProperty(Platform, 'OS', 'android');
+}
+
+test('the sheet opens /auth/mobile ephemeral, with the shell, a state, an S256 challenge and the platform', async () => {
+  WebBrowser.openAuthSessionAsync.mockResolvedValue({
+    type: 'success',
+    url: 'com.example.field://auth?token=ott-1&state=state-1',
+  });
+  const authApi = createAuthApi();
+  expect(await signInWithSheet({ apiBase, authApi, shell })).toEqual({ status: 'signedIn' });
+  const [url, redirectUrl, options] = WebBrowser.openAuthSessionAsync.mock.calls[0];
+  expect(url.startsWith(`${apiBase}/auth/mobile?`)).toBe(true);
+  const query = parseQuery(url);
+  expect(query.shell).toBe('field');
+  expect(query.state).toBe('state-1');
+  expect(query.code_challenge_method).toBe('S256');
+  expect(query.code_challenge).toMatch(/^[A-Za-z0-9_-]{43}$/);
+  expect(query.platform).toBe('ios');
+  expect(redirectUrl).toBe('com.example.field://auth');
+  expect(options).toEqual({ preferEphemeralSession: true });
+
+  // The verifier goes only to the exchange, and it is the one the challenge was made from.
+  const { token, codeVerifier } = authApi.exchangeToken.mock.calls[0][0];
+  expect(token).toBe('ott-1');
+  expect(codeVerifier).toHaveLength(86);
+  expect(base64Url(createHash('sha256').update(codeVerifier).digest())).toBe(query.code_challenge);
+  expect(url).not.toContain(codeVerifier);
+});
+
+test('each sign-in makes a new verifier, which stays in the call that made it', async () => {
+  WebBrowser.openAuthSessionAsync.mockResolvedValue({
+    type: 'success',
+    url: 'com.example.field://auth?token=ott-1&state=state-1',
+  });
+  const authApi = createAuthApi();
+  await signInWithSheet({ apiBase, authApi, shell });
+  await signInWithSheet({ apiBase, authApi, shell });
+  const [first, second] = authApi.exchangeToken.mock.calls.map(([params]) => params.codeVerifier);
+  expect(first).not.toBe(second);
+  // No call out of the sign-in but the exchange carries the verifier: not the sheet, not storage.
+  const Crypto = jest.requireMock('expo-crypto');
+  const otherCalls = JSON.stringify([
+    WebBrowser.openAuthSessionAsync.mock.calls,
+    Crypto.randomUUID.mock.calls,
+    Crypto.getRandomBytes.mock.calls,
+  ]);
+  expect(otherCalls).not.toContain(first);
+  expect(otherCalls).not.toContain(second);
+});
+
+test('a redirect with another state is refused and the token is not exchanged', async () => {
+  WebBrowser.openAuthSessionAsync.mockResolvedValue({
+    type: 'success',
+    url: 'com.example.field://auth?token=ott-1&state=someone-else',
+  });
+  const authApi = createAuthApi();
+  expect(await signInWithSheet({ apiBase, authApi, shell })).toEqual({ status: 'failed' });
+  expect(authApi.exchangeToken).not.toHaveBeenCalled();
+});
+
+test('a redirect without a token fails', async () => {
+  WebBrowser.openAuthSessionAsync.mockResolvedValue({
+    type: 'success',
+    url: 'com.example.field://auth?state=state-1',
+  });
+  const authApi = createAuthApi();
+  expect(await signInWithSheet({ apiBase, authApi, shell })).toEqual({ status: 'failed' });
+  expect(authApi.exchangeToken).not.toHaveBeenCalled();
+});
+
+test('on Android the sheet returns by the https app link and exchanges its token', async () => {
+  onAndroid();
+  WebBrowser.openAuthSessionAsync.mockResolvedValue({
+    type: 'success',
+    url: `${apiBase}/auth/mobile/callback?token=ott-1&state=state-1`,
+  });
+  const authApi = createAuthApi();
+  expect(await signInWithSheet({ apiBase, authApi, shell })).toEqual({ status: 'signedIn' });
+  const [url, redirectUrl] = WebBrowser.openAuthSessionAsync.mock.calls[0];
+  expect(parseQuery(url).platform).toBe('android');
+  expect(redirectUrl).toBe(`${apiBase}/auth/mobile/callback`);
+  expect(authApi.exchangeToken.mock.calls[0][0].token).toBe('ott-1');
+});
+
+test('on Android a callback with another state is refused and the token is not exchanged', async () => {
+  onAndroid();
+  WebBrowser.openAuthSessionAsync.mockResolvedValue({
+    type: 'success',
+    url: `${apiBase}/auth/mobile/callback?token=ott-1&state=someone-else`,
+  });
+  const authApi = createAuthApi();
+  expect(await signInWithSheet({ apiBase, authApi, shell })).toEqual({ status: 'failed' });
+  expect(authApi.exchangeToken).not.toHaveBeenCalled();
+});
+
+test('on Android a return to the custom scheme is not the app link and is refused', async () => {
+  onAndroid();
+  WebBrowser.openAuthSessionAsync.mockResolvedValue({
+    type: 'success',
+    url: 'com.example.field://auth?token=ott-1&state=state-1',
+  });
+  const authApi = createAuthApi();
+  expect(await signInWithSheet({ apiBase, authApi, shell })).toEqual({ status: 'failed' });
+  expect(authApi.exchangeToken).not.toHaveBeenCalled();
+});
+
+test('Cancel on the confirmation page cancels the sign-in', async () => {
+  WebBrowser.openAuthSessionAsync.mockResolvedValue({
+    type: 'success',
+    url: 'com.example.field://auth?error=cancelled&state=state-1',
+  });
+  const authApi = createAuthApi();
+  expect(await signInWithSheet({ apiBase, authApi, shell })).toEqual({ status: 'cancelled' });
+  expect(authApi.exchangeToken).not.toHaveBeenCalled();
+});
+
+test('getSheetReturnUrl is the scheme on iOS and the app link under the app url on Android', () => {
+  expect(getSheetReturnUrl({ apiBase, platform: 'ios', shell })).toBe('com.example.field://auth');
+  expect(getSheetReturnUrl({ apiBase: `${apiBase}/app/`, platform: 'android', shell })).toBe(
+    `${apiBase}/app/auth/mobile/callback`
+  );
+});
+
+test('isSheetReturnLink tells the app link return from page links', () => {
+  expect(isSheetReturnLink(`${apiBase}/auth/mobile/callback?token=ott-1&state=s`)).toBe(true);
+  expect(isSheetReturnLink(`${apiBase}/app/auth/mobile/callback`)).toBe(true);
+  expect(isSheetReturnLink('/auth/mobile/callback?token=ott-1')).toBe(true);
+  expect(isSheetReturnLink(`${apiBase}/auth/mobile`)).toBe(false);
+  expect(isSheetReturnLink(`${apiBase}/jobs?next=/auth/mobile/callback`)).toBe(false);
+  expect(isSheetReturnLink('/jobs/42')).toBe(false);
+  expect(isSheetReturnLink('com.example.field://jobs')).toBe(false);
+});
+
+test('closing the sheet cancels the sign-in', async () => {
+  WebBrowser.openAuthSessionAsync.mockResolvedValue({ type: 'cancel' });
+  const authApi = createAuthApi();
+  expect(await signInWithSheet({ apiBase, authApi, shell })).toEqual({ status: 'cancelled' });
+  expect(authApi.exchangeToken).not.toHaveBeenCalled();
+});
+
+test('parseQuery reads a custom-scheme URL query, decoding each value', () => {
+  expect(parseQuery('com.example.field://auth?token=a%2Bb&state=x+y&empty#frag')).toEqual({
+    token: 'a+b',
+    state: 'x y',
+    empty: '',
+  });
+  expect(parseQuery('com.example.field://auth')).toEqual({});
+});

package/src/auth/styles.js

@@ -0,0 +1,78 @@
+/*
+  Copyright 2020-2026 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/
+
+import { StyleSheet } from 'react-native';
+
+const styles = StyleSheet.create({
+  screen: {
+    flexGrow: 1,
+    justifyContent: 'center',
+    padding: 24,
+    gap: 16,
+  },
+  appName: {
+    fontSize: 28,
+    fontWeight: '700',
+    textAlign: 'center',
+    marginBottom: 8,
+  },
+  label: {
+    fontSize: 16,
+  },
+  input: {
+    borderRadius: 10,
+    paddingHorizontal: 16,
+    paddingVertical: 12,
+    fontSize: 17,
+  },
+  codeInput: {
+    letterSpacing: 8,
+    textAlign: 'center',
+    fontSize: 24,
+  },
+  message: {
+    fontSize: 15,
+  },
+  error: {
+    fontSize: 15,
+  },
+  button: {
+    alignItems: 'center',
+    paddingVertical: 14,
+    borderRadius: 12,
+  },
+  buttonDisabled: {
+    opacity: 0.5,
+  },
+  buttonText: {
+    color: '#FFFFFF',
+    fontSize: 17,
+    fontWeight: '600',
+  },
+  links: {
+    flexDirection: 'row',
+    justifyContent: 'space-between',
+  },
+  link: {
+    fontSize: 17,
+    paddingVertical: 8,
+  },
+  centered: {
+    alignSelf: 'center',
+  },
+});
+
+export default styles;

package/src/auth/unregisterPushToken.js

@@ -0,0 +1,62 @@
+/*
+  Copyright 2020-2026 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/
+
+import { Platform } from 'react-native';
+import * as Notifications from 'expo-notifications';
+
+import callEndpoint from '../native/callEndpoint.js';
+
+// This phone's native push token (APNs or FCM), as registerPushToken sent it; null when the phone
+// has none (never allowed to notify, no signal).
+async function getDeviceToken() {
+  try {
+    const { data } = await Notifications.getDevicePushTokenAsync();
+    return data ?? null;
+  } catch (error) {
+    return null;
+  }
+}
+
+/**
+ * Tells the app's mobile.notifications.unregister endpoint that this phone signs out, so no
+ * notification for the person reaches it afterwards: { token, platform, shellId }, with the session
+ * that is ending, so the app drops this phone's token and keeps the person's other phones. Called
+ * before the token is removed, and never waited on: offline, the sign-out still ends on the phone,
+ * and the app drops the token when a push to it fails.
+ *
+ * A session the server already ended (a 401 clears the token, createAppAuth handleTokenChange)
+ * has no session left to call with, so nothing is unregistered: the push token stays with the app
+ * until a push to it fails or the phone registers for someone else.
+ *
+ * @param {Object} params
+ * @param {Object} params.app { apiBase, fetch, session, shell, tokenStore }.
+ */
+async function unregisterPushToken({ app }) {
+  const endpointId = app.session?.getState().root?.notifications?.unregister;
+  const sessionToken = app.tokenStore.get();
+  if (typeof endpointId !== 'string' || sessionToken === null) {
+    return;
+  }
+  // The sign-out clears the token store while the device token is still being read, so the call
+  // carries the session token as it was when the sign-out began.
+  await callEndpoint({
+    app: { ...app, tokenStore: { get: () => sessionToken } },
+    endpointId,
+    payload: { token: await getDeviceToken(), platform: Platform.OS, shellId: app.shell.id },
+  });
+}
+
+export default unregisterPushToken;

package/src/auth/unregisterPushToken.test.js

@@ -0,0 +1,67 @@
+/*
+  Copyright 2020-2026 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/
+
+import { Platform } from 'react-native';
+import * as Notifications from 'expo-notifications';
+
+import callEndpoint from '../native/callEndpoint.js';
+import unregisterPushToken from './unregisterPushToken.js';
+
+jest.mock('../native/callEndpoint.js', () => jest.fn(async () => null));
+jest.mock('expo-notifications', () => ({
+  getDevicePushTokenAsync: jest.fn(async () => ({ data: 'device-token' })),
+}));
+
+function createApp({ token = 'session-token' } = {}) {
+  return {
+    session: { getState: () => ({ root: { notifications: { unregister: 'drop_push' } } }) },
+    shell: { id: 'field' },
+    tokenStore: { get: () => token },
+  };
+}
+
+test('a sign-out sends this phone push token, so the app drops that one', async () => {
+  await unregisterPushToken({ app: createApp() });
+  expect(callEndpoint).toHaveBeenCalledWith(
+    expect.objectContaining({
+      endpointId: 'drop_push',
+      payload: { token: 'device-token', platform: Platform.OS, shellId: 'field' },
+    })
+  );
+});
+
+test('a sign-out that clears the session token while the push token is read still calls with it', async () => {
+  const app = createApp();
+  let current = 'session-token';
+  app.tokenStore = { get: () => current };
+  Notifications.getDevicePushTokenAsync.mockImplementationOnce(async () => {
+    current = null;
+    return { data: 'device-token' };
+  });
+  await unregisterPushToken({ app });
+  expect(callEndpoint.mock.calls[0][0].app.tokenStore.get()).toBe('session-token');
+});
+
+test('a phone without a push token sends token null', async () => {
+  Notifications.getDevicePushTokenAsync.mockRejectedValueOnce(new Error('not registered'));
+  await unregisterPushToken({ app: createApp() });
+  expect(callEndpoint.mock.calls[0][0].payload.token).toBeNull();
+});
+
+test('a session that already ended unregisters nothing', async () => {
+  await unregisterPushToken({ app: createApp({ token: null }) });
+  expect(callEndpoint).not.toHaveBeenCalled();
+});

package/src/auth/usesBiometricUnlock.js

@@ -0,0 +1,23 @@
+/*
+  Copyright 2020-2026 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/
+
+// Biometric unlock is on when the app asks for it, except on a shared device, which signs out on
+// every close instead.
+function usesBiometricUnlock(settings) {
+  return settings?.unlock === 'biometric' && settings.sharedDevice !== true;
+}
+
+export default usesBiometricUnlock;

package/src/auth/watchSession.js

@@ -0,0 +1,47 @@
+/*
+  Copyright 2020-2026 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/
+
+import { parseCallerStamp } from '@lowdefy/helpers';
+
+function sentToken(headers) {
+  return Object.keys(headers ?? {}).some((name) => name.toLowerCase() === 'authorization');
+}
+
+/**
+ * The fetch the app's session and core call the server with, watching what the server says of
+ * the session token a call carried:
+ * - a 401, or an answer as the signed-out caller (an empty x-lowdefy-caller stamp): the session is
+ *   gone (signed out elsewhere, ended by an admin, expired), so onSessionEnded;
+ * - a 403: this organisation refused the person (removed, or no longer allowed), so onRefused.
+ * A call that carried no token says nothing about a session.
+ */
+function watchSession({ fetch, onRefused, onSessionEnded }) {
+  return async function watchedFetch(url, init = {}) {
+    const res = await fetch(url, init);
+    if (!sentToken(init.headers)) {
+      return res;
+    }
+    const stamp = parseCallerStamp(res.headers.get('x-lowdefy-caller'));
+    if (res.status === 401 || stamp?.caller === '') {
+      onSessionEnded();
+    } else if (res.status === 403) {
+      onRefused();
+    }
+    return res;
+  };
+}
+
+export default watchSession;

package/src/auth/withoutCookies.js

@@ -0,0 +1,26 @@
+/*
+  Copyright 2020-2026 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/
+
+// Every call a shell makes leaves cookies alone. React Native's fetch keeps a cookie jar unless
+// told not to, and a request carrying a Cookie is not a native one to the server: it would get
+// no set-auth-token on sign-in. The session travels only as the bearer token.
+function withoutCookies(fetch) {
+  return function cookielessFetch(url, init = {}) {
+    return fetch(url, { ...init, credentials: 'omit' });
+  };
+}
+
+export default withoutCookies;

package/src/cache/createSqliteCacheStore.js

@@ -0,0 +1,113 @@
+/*
+  Copyright 2020-2026 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/
+
+// The page cache in SQLite: per cache key (getCacheKey), the mobile root with its ETag and the
+// caller, and each page with its index hash and ETag. All of it is the server's answers kept as
+// JSON; nothing here is shared between callers.
+const SCHEMA = `
+CREATE TABLE IF NOT EXISTS roots (
+  cache_key TEXT PRIMARY KEY NOT NULL,
+  root TEXT NOT NULL,
+  root_etag TEXT,
+  user TEXT
+);
+CREATE TABLE IF NOT EXISTS pages (
+  cache_key TEXT NOT NULL,
+  page_id TEXT NOT NULL,
+  page TEXT NOT NULL,
+  PRIMARY KEY (cache_key, page_id)
+);
+`;
+
+/**
+ * @param {Object} params
+ * @param {Object} params.db An expo-sqlite database (openDatabaseSync).
+ */
+function createSqliteCacheStore({ db }) {
+  let ready = null;
+  function init() {
+    if (ready === null) {
+      ready = db.execAsync(SCHEMA);
+    }
+    return ready;
+  }
+
+  return {
+    async read(cacheKey) {
+      await init();
+      const row = await db.getFirstAsync(
+        'SELECT root, root_etag, user FROM roots WHERE cache_key = ?',
+        [cacheKey]
+      );
+      if (row === null) {
+        return null;
+      }
+      const pageRows = await db.getAllAsync('SELECT page_id, page FROM pages WHERE cache_key = ?', [
+        cacheKey,
+      ]);
+      return {
+        root: JSON.parse(row.root),
+        rootEtag: row.root_etag,
+        user: JSON.parse(row.user),
+        pages: Object.fromEntries(pageRows.map((page) => [page.page_id, JSON.parse(page.page)])),
+      };
+    },
+    async writeRoot({ cacheKey, entry }) {
+      await init();
+      await db.runAsync(
+        'INSERT OR REPLACE INTO roots (cache_key, root, root_etag, user) VALUES (?, ?, ?, ?)',
+        [cacheKey, JSON.stringify(entry.root), entry.rootEtag ?? null, JSON.stringify(entry.user)]
+      );
+    },
+    async writePage({ cacheKey, pageId, page }) {
+      await init();
+      await db.runAsync(
+        'INSERT OR REPLACE INTO pages (cache_key, page_id, page) VALUES (?, ?, ?)',
+        [cacheKey, pageId, JSON.stringify(page)]
+      );
+    },
+    // One caller's cache: an organisation that refused the person.
+    async removeEntry({ cacheKey }) {
+      await init();
+      await db.runAsync('DELETE FROM roots WHERE cache_key = ?', [cacheKey]);
+      await db.runAsync('DELETE FROM pages WHERE cache_key = ?', [cacheKey]);
+    },
+    // Every caller's cache of one app (getCacheKey starts each key with the app id): sign-out.
+    async removeApp({ appId }) {
+      await init();
+      const prefix = `${appId}:`;
+      await db.runAsync('DELETE FROM roots WHERE substr(cache_key, 1, length(?)) = ?', [
+        prefix,
+        prefix,
+      ]);
+      await db.runAsync('DELETE FROM pages WHERE substr(cache_key, 1, length(?)) = ?', [
+        prefix,
+        prefix,
+      ]);
+    },
+    async removePages({ cacheKey, pageIds }) {
+      await init();
+      for (const pageId of pageIds) {
+        await db.runAsync('DELETE FROM pages WHERE cache_key = ? AND page_id = ?', [
+          cacheKey,
+          pageId,
+        ]);
+      }
+    },
+  };
+}
+
+export default createSqliteCacheStore;