createOfflineSync.ts

#!/usr/bin/env npx ts-node --compiler-options {"module":"commonjs"}

import {createDomain} from "../connect";
import {IdbStorageAdapter} from "../../main/storage/idb/";
import {RealTimeModel} from "../../main";
import {OfflineModelDownloadCompletedEvent} from "../../main/model/events/OfflineModelDownloadCompletedEvent";

// tslint:disable-next-line
require("fake-indexeddb/auto");

const MODELS_TO_CREATE = 6;
let modelIds: string[] = [];
let rtManifest;

const domain = createDomain({
  offline: {
    storage: new IdbStorageAdapter()
  }
});

async function createModels(): Promise<void> {
  for (let i = 0; i < MODELS_TO_CREATE; i++) {
    let id = `created-offline-${i}`;
    await createModel(id);
    rtManifest.root().set(id, new Date().getTime());
    modelIds.push(id);
    console.log("Created model", id);
  }
  await rtManifest.close();
}

async function createModel(id: string): Promise<string> {
  let modelService = domain.models();

  let model = await modelService.openAutoCreate({
    id,
    collection: "test"
  });
  await model.close();
  return model.modelId();
}

function createManifest(): Promise<RealTimeModel> {
  let modelService = domain.models();

  return modelService.openAutoCreate({
    id: "manifest",
    collection: "test"
  });
}

async function cleanupModels(): Promise<void> {
  for (let id of modelIds) {
    console.log("deleting", id);
    await domain.models().remove(id).catch(e => console.error(e));
  }
  await domain.models().remove("manifest").catch(e => console.error(e));
}

async function create() {
  console.log("connecting online");

  await domain.connectWithPassword({username: "test", password: "password"});

  rtManifest = await createManifest();
  await createModels();

  process.exit();
}
async function subscribeToMost() {
  await domain.connectWithPassword({username: "test", password: "password"});

  domain.models().on(OfflineModelDownloadCompletedEvent.NAME, async () => {
    console.log("model download completed");

    process.exit();
  });

  await domain.models().open("manifest");

  for (let i = 0; i < MODELS_TO_CREATE; i++) {
    modelIds.push(`created-offline-${i}`);
  }
  modelIds.push("manifest");

  domain.models().setOfflineSubscription(modelIds);
}

async function cleanUp() {
  for (let i = 0; i < MODELS_TO_CREATE; i++) {
    modelIds.push(`created-offline-${i}`);
  }

  await domain.connectWithPassword({username: "test", password: "password"});
  await cleanupModels();
  process.exit();
}

create().catch(e => console.error(e));
// subscribeToMost().catch(e => console.error(e));
// cleanUp().catch(e => console.error(e));