@natify/storage-async

Storage adapter for Natify Framework using @react-native-async-storage/async-storage.

Installation

``bash
pnpm add @natify/storage-async @react-native-async-storage/async-storage
`

When to Use

| Adapter | Use Case |
|---------|----------|
| storage-async | Non-sensitive data, maximum compatibility |
| storage-mmkv | High performance, frequent data access |
| storage-keychain | Sensitive data (tokens, passwords) |

AsyncStorage is ideal for:
- User preferences
- Data cache
- Onboarding state
- App configurations

DO NOT use for:
- Authentication tokens (use Keychain)
- Passwords
- Sensitive data

Usage

$3

`typescript
import { NatifyProvider } from "@natify/core";
import { AsyncStorageAdapter } from "@natify/storage-async";

const config = {
storage: new AsyncStorageAdapter(),
// ... other adapters
};

function App() {
return (



);
}
`

$3

`typescript
import { useAdapter, StoragePort } from "@natify/core";

function SettingsScreen() {
const storage = useAdapter("storage");

// Save preferences
const saveTheme = async (theme: "light" | "dark") => {
await storage.setItem("user_theme", theme);
};

// Read preferences
const loadTheme = async () => {
const theme = await storage.getItem("user_theme");
return theme || "light";
};

// Save complex object
const saveUserPreferences = async (prefs: UserPreferences) => {
await storage.setItem("user_preferences", prefs);
};

// Read complex object
const loadUserPreferences = async () => {
const prefs = await storage.getItem("user_preferences");
return prefs || defaultPreferences;
};
}
`

$3

`typescript
function OnboardingCheck() {
const storage = useAdapter("storage");
const [showOnboarding, setShowOnboarding] = useState(true);

useEffect(() => {
checkOnboarding();
}, []);

const checkOnboarding = async () => {
const completed = await storage.getItem("onboarding_completed");
setShowOnboarding(!completed);
};

const completeOnboarding = async () => {
await storage.setItem("onboarding_completed", true);
setShowOnboarding(false);
};

if (showOnboarding) {
return ;
}

return ;
}
`

$3

`typescript
interface CachedData {
data: T;
timestamp: number;
expiresIn: number;
}

function useCachedData(key: string, fetcher: () => Promise, ttl = 3600000) {
const storage = useAdapter("storage");

const getData = async (): Promise => {
const cached = await storage.getItem>(cache_${key});

if (cached && Date.now() - cached.timestamp < cached.expiresIn) {
return cached.data;
}

const freshData = await fetcher();
await storage.setItem>(cache_${key}, {
data: freshData,
timestamp: Date.now(),
expiresIn: ttl,
});

return freshData;
};

return { getData };
}
`

API

$3

| Method | Return | Description |
|--------|--------|-------------|
| getItem(key) | Promise | Gets a value by key |
| setItem(key, value) | Promise | Saves a value |
| removeItem(key) | Promise | Removes a value |
| clear() | Promise | Clears all storage |

$3

The adapter automatically serializes/deserializes:

- string
- number
- boolean
- object (JSON serializable)
- array` (JSON serializable)

Limitations

- Asynchronous: All operations are async (non-blocking)
- Performance: Slower than MMKV for frequent operations
- No encryption: Data is not encrypted (use Keychain for sensitive data)
- Size limit: ~6MB on Android, no limit on iOS