@aerogel/plugin-local-first 0.1.1 → 0.1.2-next.2c3536aed027b7db949ee77b64a6cf2dc1281eaf

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Noel De Martin
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/aerogel-plugin-local-first.d.ts

@@ -1,31 +1,19 @@
-import { AcceptRefs } from '@aerogel/core';
 import { Authenticator } from '@aerogel/plugin-solid';
 import { ComponentOptionsMixin } from 'vue';
 import { ComponentProvideOptions } from 'vue';
-import { Cr } from '@noeldemartin/utils';
 import { DefineComponent } from 'vue';
-import { Engine } from 'soukai';
+import { Engine } from 'soukai-bis';
 import { ErrorSource } from '@aerogel/core';
 import { Facade } from '@noeldemartin/utils';
-import { Job } from '@aerogel/core';
-import { JobListener } from '@aerogel/core';
-import { JobStatus } from '@aerogel/core';
-import { ModalExpose } from '@aerogel/core';
+import { JobListener } from 'soukai-bis';
+import { Model } from 'soukai-bis';
+import { ModelConstructor } from 'soukai-bis';
 import { Nullable } from '@noeldemartin/utils';
-import { ObjectsMap } from '@noeldemartin/utils';
 import { Plugin as Plugin_2 } from '@aerogel/core';
 import { PublicProps } from 'vue';
-import { Replace } from '@aerogel/core';
 import { Semaphore } from '@noeldemartin/utils';
 import { ServiceWithState } from '@aerogel/core';
-import { ShallowUnwrapRef } from 'vue';
-import { SolidContainer } from 'soukai-solid';
-import { SolidDocument } from 'soukai-solid';
-import { SolidModel } from 'soukai-solid';
-import { SolidModelConstructor } from 'soukai-solid';
-import { SolidSchemaDefinition } from 'soukai-solid';
-import { SolidTypeIndex } from 'soukai-solid';
-import { Tombstone } from 'soukai-solid';
+import { Sync } from 'soukai-bis';
 
 export declare const Account: DefineComponent<    {}, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
 
@@ -35,46 +23,48 @@ export declare const AccountLoggedOut: DefineComponent<    {}, {}, {}, {}, {}, C
 
 export declare const AccountLoginModal: DefineComponent<    {}, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
 
-export declare const AccountModal: DefineComponent<    {}, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {
-$modalRef: ShallowUnwrapRef<AcceptRefs<ModalExpose<void>>> | null;
-}, any>;
+export declare const AccountModal: DefineComponent<    {}, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
 
 export declare const Cloud: Facade<CloudService>;
 
+export declare type CloudRegistration = boolean | RegisterOptions | undefined;
+
 export declare class CloudService extends _default {
     protected asyncLock: Semaphore;
     protected engine: Engine | null;
-    protected pollingInterval: NodeJS.Timeout | null;
+    protected pollingInterval: ReturnType<typeof setInterval> | null;
     whenReady<T>(callback: () => T): Promise<T>;
-    setup(modelUrlMappings?: WeakMap<SolidModelConstructor, Record<string, string>>): Promise<void>;
+    setup(): Promise<void>;
+    getEngine(): Engine | null;
+    requireEngine(): Engine;
     dismissSetup(): void;
-    dismissMigration(): void;
-    postponeMigration(): void;
     syncIfOnline(options?: SyncOptions): Promise<void>;
-    syncIfOnline(model: SolidModel): Promise<void>;
-    syncIfOnline(models: SolidModel[]): Promise<void>;
+    syncIfOnline(model: Model): Promise<void>;
+    syncIfOnline(models: Model[]): Promise<void>;
     sync(options?: SyncOptions): Promise<void>;
-    sync(model: SolidModel): Promise<void>;
-    sync(models: SolidModel[]): Promise<void>;
-    shouldMigrate(): boolean;
-    migrate(listener?: JobListener): Promise<void>;
-    register(modelClass: SolidModelConstructor, options?: RegisterOptions): Promise<void>;
-    registerSchemaMigration(modelClass: SolidModelConstructor, schema: SolidModelConstructor | SolidSchemaDefinition): void;
-    requireRemoteCollection(modelClass: SolidModelConstructor): string;
+    sync(model: Model): Promise<void>;
+    sync(models: Model[]): Promise<void>;
+    track(modelClass: ModelConstructor, options?: {
+        register?: CloudRegistration;
+    }): Promise<void>;
+    requireRemoteContainerUrl(modelClass: ModelConstructor): string;
     protected boot(): Promise<void>;
-    protected getDirtyLocalModels(): SolidModel[];
-    protected getModelsIn(urls: string[], model: SolidModel): SolidModel[];
-    protected requireEngine(): Engine;
+    protected getDirtyLocalModels(): Model[];
+    protected getModelsIn(urls: string[], model: Model): Model[];
     protected setReady(ready: boolean): Promise<void>;
-    protected backup(modelUrlMappings?: WeakMap<SolidModelConstructor, Record<string, string>>): Promise<void>;
+    protected migrateLocalUrls(): Promise<void>;
     protected onApplicationReady(): Promise<void>;
     protected onApplicationMounted(): Promise<void>;
     protected login(authenticator: Authenticator): void;
-    protected logout(): void;
+    protected logout(): Promise<void>;
     private watchNetworkStatus;
     private syncOnStartup;
-    private bustDocumentsCache;
-    private registerModels;
+    private setupRemoteCollection;
+    private trackModels;
+    private refreshTrackedModels;
+    private clearLocalModelUpdates;
+    private onModelCreated;
+    private onModelUpdated;
 }
 
 declare const CloudStatus: {
@@ -82,21 +72,17 @@ declare const CloudStatus: {
     readonly Offline: "offline";
     readonly Online: "online";
     readonly Syncing: "syncing";
-    readonly Migrating: "migrating";
 };
 
 declare const _default: ServiceWithState<    {
 autoPush: boolean;
 localModelUpdates: Record<string, number>;
-migrationDismissed: boolean;
-migrationJob: Nullable<Migrate>;
-migrationPostponed: boolean;
-modelCollections: Record<string, string[]>;
+rootContainerUrls: Record<string, string>;
 pollingEnabled: boolean;
 pollingMinutes: number;
 ready: boolean;
+manualSetup: boolean;
 registeredModels: ModelRegistration[];
-schemaMigrations: Map<SolidModelConstructor, SolidModelConstructor | SolidSchemaDefinition>;
 setupDismissed: boolean;
 setupOngoing: boolean;
 startupSync: boolean;
@@ -108,171 +94,57 @@ disconnected: boolean;
 online: boolean;
 offline: boolean;
 syncing: boolean;
-migrating: boolean;
 localChanges: number;
 dirty: boolean;
-migrationStarted: boolean;
-migrationDisabledReason: string | null;
-}, Replace<Partial<{
+}, Partial<{
 autoPush: boolean;
 localModelUpdates: Record<string, number>;
-migrationDismissed: boolean;
-migrationJob: Nullable<Migrate>;
-migrationPostponed: boolean;
-modelCollections: Record<string, string[]>;
+rootContainerUrls: Record<string, string>;
 pollingEnabled: boolean;
 pollingMinutes: number;
 ready: boolean;
+manualSetup: boolean;
 registeredModels: ModelRegistration[];
-schemaMigrations: Map<SolidModelConstructor, SolidModelConstructor | SolidSchemaDefinition>;
 setupDismissed: boolean;
 setupOngoing: boolean;
 startupSync: boolean;
 status: TCloudStatus;
 syncError: Nullable<ErrorSource>;
 syncJob: Nullable<Sync>;
-}>, {
-migrationJob: MigrateJobStatus | undefined;
 }>>;
 
-declare class LoadsChildren {
-    protected localModels?: ObjectsMap<SolidModel>;
-    protected loadContainedModels(model: SolidContainer, options?: {
-        ignoreTombstones?: boolean;
-        status?: ResourceJobStatus;
-        onDocumentLoaded?: () => unknown;
-        onDocumentError?: (error: unknown) => unknown;
-        onDocumentRead?: (document: SolidDocument) => unknown;
-    }): Promise<SolidModel[]>;
-    protected loadDocumentChildren(model: SolidContainer, documentUrl: string, documents: ObjectsMap<SolidDocument>, onDocumentError?: (error: unknown) => unknown, onDocumentRead?: (document: SolidDocument) => unknown): Promise<{
-        children: Record<string, SolidModel[]>;
-        tombstones: Tombstone[];
-    }>;
-    protected loadDocumentChildrenFromLocal(model: SolidModel, document: SolidDocument): Promise<Record<string, SolidModel[]>>;
-    protected loadDocumentChildrenFromRemote(model: SolidContainer, documentUrl: string, onDocumentError?: (error: unknown) => unknown, onDocumentRead?: (document: SolidDocument) => unknown): Promise<{
-        children: Record<string, SolidModel[]>;
-        tombstones: Tombstone[];
-    }>;
-}
-
-declare class LoadsTypeIndex {
-    protected loadTypeIndex(options?: {
-        create?: false;
-        fresh?: boolean;
-    }): Promise<SolidTypeIndex | null>;
-    protected loadTypeIndex(options?: {
-        create?: true;
-        fresh?: boolean;
-    }): Promise<SolidTypeIndex>;
-}
-
-declare function localFirst(): Plugin_2;
+declare function localFirst(options?: Options): Plugin_2;
 export default localFirst;
 
 export declare type LocalFirstServices = typeof services;
 
-declare class Migrate extends Migrate_base {
-    static restore(status: MigrateJobStatus): Migrate;
-    constructor();
-    protected _models?: SolidModel[];
-    get models(): SolidModel[] | undefined;
-    set models(models: SolidModel[] | undefined);
-    protected run(): Promise<void>;
-    protected migrateRegisteredModel(model: SolidModel, status: MigrateModelJobStatus, typeIndex?: Nullable<SolidTypeIndex>): Promise<void>;
-    protected migrate(localModel: SolidModel, status: MigrateModelJobStatus): Promise<void>;
-    protected migrateChildren(localModel: SolidModel, status: MigrateModelJobStatus): Promise<void>;
-}
-
-declare const Migrate_base: typeof Job<JobListener, MigrateJobStatus, MigrateJobStatus> & Cr<LoadsChildren & LoadsTypeIndex & TracksLocalModels>;
-
-declare interface MigrateJobStatus extends JobStatus {
-    children?: MigrateModelJobStatus[];
-}
-
-declare interface MigrateModelJobStatus extends JobStatus {
-    modelUrl: string;
-    children?: MigrateModelJobStatus[];
-}
-
 declare interface ModelRegistration {
-    modelClass: SolidModelConstructor;
+    modelClass: ModelConstructor;
     path?: string;
 }
 
-export declare interface RegisterOptions {
-    path?: string;
+export declare interface Options {
+    manualSetup?: boolean;
 }
 
-declare interface ResourceJobStatus extends JobStatus {
-    documentUrl?: string;
-    children?: ResourceJobStatus[];
+export declare interface RegisterOptions {
+    path?: string;
+    depth?: number;
 }
 
 declare const services: {
     $cloud: Facade<CloudService>;
 };
 
-declare class Sync extends Sync_base {
-    readonly documentsWithErrors: Set<string>;
-    protected models?: SolidModel[];
-    protected dirtyRemoteModels?: SolidModel[];
-    protected rootLocalModels: SolidModel[];
-    protected tombstones: ObjectsMap<Tombstone>;
-    protected syncedModelUrls: Set<string>;
-    protected documentsModifiedAt: Record<string, Date>;
-    protected screenLock: Promise<void | {
-        release(): Promise<void>;
-    }> | null;
-    protected localModels: ObjectsMap<SolidModel>;
-    constructor(models?: SolidModel[]);
-    protected run(): Promise<void>;
-    protected lockScreen(): void;
-    protected releaseScreen(): void;
-    protected getInitialStatus(): SyncJobStatus;
-    protected calculateCurrentProgress(status?: JobStatus): number;
-    private pullChanges;
-    private pushChanges;
-    private fetchRemoteModels;
-    private fetchRemoteModelsForLocal;
-    private getTypeRegistrations;
-    private updateTypeRegistrations;
-    private loadChildren;
-    private deleteChild;
-    private saveModelAndChildren;
-    private synchronizeModels;
-    private reconcileInconsistencies;
-    private synchronizeContainerDocuments;
-    private rememberModelDocuments;
-    private ignoringDocumentErrors;
-    private handleDocumentError;
-}
-
-declare const Sync_base: typeof Job<JobListener, SyncJobStatus, SyncJobStatus> & Cr<LoadsChildren & LoadsTypeIndex & TracksLocalModels>;
-
-declare interface SyncJobStatus extends JobStatus {
-    root: true;
-    children: [SyncPullJobStatus, JobStatus];
-}
-
 export declare interface SyncOptions extends JobListener {
-    model?: SolidModel;
-    models?: SolidModel[];
+    model?: Model;
+    models?: Model[];
     refreshUserProfile?: boolean;
     syncDirty?: boolean;
 }
 
-declare interface SyncPullJobStatus extends JobStatus {
-    children?: ResourceJobStatus[];
-}
-
 declare type TCloudStatus = (typeof CloudStatus)[keyof typeof CloudStatus];
 
-declare class TracksLocalModels {
-    protected localModels: ObjectsMap<SolidModel>;
-    protected indexLocalModels(models: SolidModel[]): Promise<void>;
-    protected addLocalModel(localModel: SolidModel): Promise<void>;
-}
-
 export { }
 
 
@@ -287,17 +159,14 @@ declare module '@aerogel/core' {
         'cloud:ready': void;
         'cloud:backup-started': void;
         'cloud:backup-completed': void;
-        'cloud:migration-started': SolidModel[];
-        'cloud:migration-cancelled': SolidModel[];
-        'cloud:migration-completed': SolidModel[];
-        'cloud:sync-started': SolidModel[] | undefined;
-        'cloud:sync-completed': SolidModel[] | undefined;
+        'cloud:sync-started': Model[] | undefined;
+        'cloud:sync-completed': Model[] | undefined;
     }
 }
 
 
-declare module 'soukai-solid' {
-    namespace SolidModel {
-        const cloud: boolean | RegisterOptions | undefined;
+declare module 'soukai-bis' {
+    namespace Model {
+        const cloud: CloudRegistration;
     }
 }