OpenParable
Skip to content
← Back to skills

Mobile Offline Storage

Development

Mobile Offline Storage is an Agent Skill for development published in the a5c-ai/babysitter repository on GitHub: a SKILL.md instruction file an AI agent can load to do this task.

Cross-platform offline-first data management

View on GitHub ↗
QUICK START

How to use this skill

Bring this guide into your coding agent with a prompt tailored to the tool you use.

  1. Open your project in Codex.
  2. Copy and paste the prompt below.
  3. Review files and risks before approving any action.
Prompt to paste
Inspect the Agent Skill at https://github.com/a5c-ai/babysitter/blob/HEAD/library/specializations/mobile-development/skills/offline-storage/SKILL.md and all supporting files. Report provenance, permissions, scripts, dependencies, and security risks. Propose an exact installation into .agents/skills/mobile-offline-storage, but wait for my approval before writing files or running scripts.

Copying this prompt does not install or run the skill. Review third-party files before use.

Mobile Offline Storage Skill

Overview

This skill provides cross-platform offline-first data management capabilities. It enables configuration of WatermelonDB, Realm, MMKV, and other offline storage solutions with sync queue architectures.

Allowed Tools

  • bash - Execute package managers and build tools
  • read - Analyze storage configurations and schemas
  • write - Generate models and sync logic
  • edit - Update storage implementations
  • glob - Search for storage files
  • grep - Search for patterns

Capabilities

WatermelonDB (React Native)

  1. Schema Definition

    • Define table schemas
    • Configure column types
    • Set up relations
    • Handle migrations
  2. Sync Engine

    • Implement sync adapters
    • Handle conflict resolution
    • Configure batch operations
    • Manage sync state

Realm (Cross-Platform)

  1. Object Schemas

    • Define Realm objects
    • Configure primary keys
    • Set up relationships
    • Handle embedded objects
  2. Realm Sync

    • Configure Device Sync
    • Handle flexible sync
    • Manage subscriptions
    • Handle conflicts

MMKV

  1. Key-Value Storage
    • Configure MMKV instances
    • Handle encryption
    • Implement migrations
    • Manage namespaces

Sync Architecture

  1. Offline-First Patterns

    • Design sync queues
    • Handle network state
    • Implement retry logic
    • Manage pending operations
  2. Conflict Resolution

    • Last-write-wins strategy
    • Merge strategies
    • User resolution UI
    • Audit logging

Target Processes

  • offline-first-architecture.js - Offline patterns
  • rest-api-integration.js - API sync
  • graphql-apollo-integration.js - GraphQL sync

Dependencies

  • WatermelonDB (React Native)
  • Realm SDK
  • MMKV
  • SQLite

Usage Examples

WatermelonDB Schema

// database/schema.ts
import { appSchema, tableSchema } from '@nozbe/watermelondb';

export const schema = appSchema({
  version: 1,
  tables: [
    tableSchema({
      name: 'posts',
      columns: [
        { name: 'title', type: 'string' },
        { name: 'body', type: 'string' },
        { name: 'is_published', type: 'boolean' },
        { name: 'author_id', type: 'string', isIndexed: true },
        { name: 'created_at', type: 'number' },
        { name: 'updated_at', type: 'number' },
      ],
    }),
    tableSchema({
      name: 'comments',
      columns: [
        { name: 'body', type: 'string' },
        { name: 'post_id', type: 'string', isIndexed: true },
        { name: 'author_id', type: 'string' },
        { name: 'created_at', type: 'number' },
      ],
    }),
  ],
});

WatermelonDB Model

// database/models/Post.ts
import { Model, Q } from '@nozbe/watermelondb';
import { field, date, children, relation } from '@nozbe/watermelondb/decorators';

export class Post extends Model {
  static table = 'posts';

  static associations = {
    comments: { type: 'has_many', foreignKey: 'post_id' },
    author: { type: 'belongs_to', key: 'author_id' },
  };

  @field('title') title!: string;
  @field('body') body!: string;
  @field('is_published') isPublished!: boolean;
  @field('author_id') authorId!: string;
  @date('created_at') createdAt!: Date;
  @date('updated_at') updatedAt!: Date;

  @children('comments') comments!: Query<Comment>;
  @relation('users', 'author_id') author!: Relation<User>;
}

Sync Queue Implementation

// sync/SyncQueue.ts
interface SyncOperation {
  id: string;
  type: 'create' | 'update' | 'delete';
  entity: string;
  payload: any;
  timestamp: number;
  retryCount: number;
}

class SyncQueue {
  private queue: SyncOperation[] = [];
  private isProcessing = false;

  async enqueue(operation: Omit<SyncOperation, 'id' | 'timestamp' | 'retryCount'>) {
    const op: SyncOperation = {
      ...operation,
      id: uuid(),
      timestamp: Date.now(),
      retryCount: 0,
    };
    this.queue.push(op);
    await this.persistQueue();
    this.processQueue();
  }

  private async processQueue() {
    if (this.isProcessing || this.queue.length === 0) return;

    const isOnline = await NetInfo.fetch().then(state => state.isConnected);
    if (!isOnline) return;

    this.isProcessing = true;

    while (this.queue.length > 0) {
      const operation = this.queue[0];
      try {
        await this.executeOperation(operation);
        this.queue.shift();
        await this.persistQueue();
      } catch (error) {
        operation.retryCount++;
        if (operation.retryCount >= 3) {
          this.queue.shift();
          await this.logFailedOperation(operation, error);
        }
        break;
      }
    }

    this.isProcessing = false;
  }

  private async executeOperation(operation: SyncOperation) {
    switch (operation.type) {
      case 'create':
        return api.post(`/${operation.entity}`, operation.payload);
      case 'update':
        return api.put(`/${operation.entity}/${operation.payload.id}`, operation.payload);
      case 'delete':
        return api.delete(`/${operation.entity}/${operation.payload.id}`);
    }
  }
}

Quality Gates

  • Data integrity verified on sync
  • Conflict resolution tested
  • Offline functionality verified
  • Migration tests passing

Related Skills

  • ios-persistence - iOS Core Data
  • android-room - Android Room
  • graphql-mobile - GraphQL offline

Version History

  • 1.0.0 - Initial release