strata-storage 1.0.0

package/scripts/configure.js

@@ -0,0 +1,444 @@
+#!/usr/bin/env node
+
+/**
+ * Strata Storage Configuration Script
+ * Usage: npx strata-storage configure
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+
+// Colors for terminal output
+const colors = {
+  reset: '\x1b[0m',
+  bright: '\x1b[1m',
+  green: '\x1b[32m',
+  yellow: '\x1b[33m',
+  blue: '\x1b[34m',
+  red: '\x1b[31m',
+  cyan: '\x1b[36m'
+};
+
+const log = {
+  info: (msg) => console.log(`${colors.blue}ℹ${colors.reset} ${msg}`),
+  success: (msg) => console.log(`${colors.green}✓${colors.reset} ${msg}`),
+  warning: (msg) => console.log(`${colors.yellow}⚠${colors.reset} ${msg}`),
+  error: (msg) => console.log(`${colors.red}✖${colors.reset} ${msg}`),
+  title: (msg) => console.log(`\n${colors.bright}${msg}${colors.reset}\n`)
+};
+
+// Configuration options
+const frameworks = ['react', 'vue', 'angular', 'none'];
+const platforms = ['web', 'ios', 'android', 'all'];
+const features = {
+  encryption: 'Enable encryption with Web Crypto API',
+  compression: 'Enable LZ-string compression',
+  sync: 'Enable cross-tab synchronization',
+  ttl: 'Enable TTL (Time To Live) support',
+  query: 'Enable advanced querying'
+};
+
+// Main configuration function
+async function configure() {
+  log.title('🗄️  Strata Storage Configuration');
+  
+  // Detect project type
+  const projectInfo = detectProject();
+  
+  // Interactive prompts
+  const config = await getConfiguration(projectInfo);
+  
+  // Generate configuration files
+  await generateFiles(config);
+  
+  // Install dependencies if needed
+  await installDependencies(config);
+  
+  // Show completion message
+  showCompletion(config);
+}
+
+// Detect project type and structure
+function detectProject() {
+  const info = {
+    hasPackageJson: false,
+    hasTsConfig: false,
+    framework: 'none',
+    packageManager: 'npm',
+    isCapacitor: false
+  };
+  
+  // Check for package.json
+  if (fs.existsSync('package.json')) {
+    info.hasPackageJson = true;
+    const pkg = JSON.parse(fs.readFileSync('package.json', 'utf8'));
+    
+    // Detect framework
+    if (pkg.dependencies?.react || pkg.devDependencies?.react) {
+      info.framework = 'react';
+    } else if (pkg.dependencies?.vue || pkg.devDependencies?.vue) {
+      info.framework = 'vue';
+    } else if (pkg.dependencies?.['@angular/core'] || pkg.devDependencies?.['@angular/core']) {
+      info.framework = 'angular';
+    }
+    
+    // Detect Capacitor
+    if (pkg.dependencies?.['@capacitor/core']) {
+      info.isCapacitor = true;
+    }
+    
+    // Detect package manager
+    if (fs.existsSync('yarn.lock')) {
+      info.packageManager = 'yarn';
+    } else if (fs.existsSync('pnpm-lock.yaml')) {
+      info.packageManager = 'pnpm';
+    }
+  }
+  
+  // Check for TypeScript
+  if (fs.existsSync('tsconfig.json')) {
+    info.hasTsConfig = true;
+  }
+  
+  return info;
+}
+
+// Get configuration through prompts
+async function getConfiguration(projectInfo) {
+  const readline = require('readline');
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  
+  const question = (prompt) => new Promise((resolve) => {
+    rl.question(prompt, resolve);
+  });
+  
+  const config = {
+    framework: projectInfo.framework,
+    platforms: [],
+    features: {},
+    typescript: projectInfo.hasTsConfig,
+    packageManager: projectInfo.packageManager
+  };
+  
+  log.info(`Detected: ${projectInfo.framework === 'none' ? 'Vanilla JS' : projectInfo.framework} project`);
+  
+  // Framework selection (if not detected)
+  if (projectInfo.framework === 'none') {
+    console.log('\nWhich framework are you using?');
+    frameworks.forEach((f, i) => console.log(`  ${i + 1}) ${f}`));
+    
+    const frameworkChoice = await question('\nSelect framework (1-4): ');
+    config.framework = frameworks[parseInt(frameworkChoice) - 1] || 'none';
+  }
+  
+  // Platform selection
+  console.log('\nWhich platforms will you target?');
+  platforms.forEach((p, i) => console.log(`  ${i + 1}) ${p}`));
+  
+  const platformChoice = await question('\nSelect platform (1-4): ');
+  const selectedPlatform = platforms[parseInt(platformChoice) - 1] || 'web';
+  
+  if (selectedPlatform === 'all') {
+    config.platforms = ['web', 'ios', 'android'];
+  } else {
+    config.platforms = [selectedPlatform];
+  }
+  
+  // Feature selection
+  console.log('\nWhich features do you want to enable?');
+  for (const [key, desc] of Object.entries(features)) {
+    const enable = await question(`${desc}? (y/N): `);
+    config.features[key] = enable.toLowerCase() === 'y';
+  }
+  
+  // TypeScript
+  if (!projectInfo.hasTsConfig) {
+    const useTs = await question('\nUse TypeScript? (Y/n): ');
+    config.typescript = useTs.toLowerCase() !== 'n';
+  }
+  
+  rl.close();
+  return config;
+}
+
+// Generate configuration files
+async function generateFiles(config) {
+  log.title('Generating configuration files...');
+  
+  // Create strata.config.js
+  const configContent = generateConfigFile(config);
+  fs.writeFileSync('strata.config.js', configContent);
+  log.success('Created strata.config.js');
+  
+  // Create TypeScript declaration if needed
+  if (config.typescript) {
+    const dtsContent = generateTypeDeclaration();
+    fs.writeFileSync('strata.d.ts', dtsContent);
+    log.success('Created strata.d.ts');
+  }
+  
+  // Create example file
+  const exampleContent = generateExampleFile(config);
+  const examplePath = `strata.example.${config.typescript ? 'ts' : 'js'}`;
+  fs.writeFileSync(examplePath, exampleContent);
+  log.success(`Created ${examplePath}`);
+  
+  // Update .gitignore
+  updateGitignore();
+}
+
+// Generate config file content
+function generateConfigFile(config) {
+  const enabledFeatures = Object.entries(config.features)
+    .filter(([_, enabled]) => enabled)
+    .map(([key]) => key);
+  
+  return `/**
+ * Strata Storage Configuration
+ * Generated by: npx strata-storage configure
+ */
+
+${config.typescript ? "import type { StrataConfig } from 'strata-storage';\n" : ''}
+${config.typescript ? 'const config: StrataConfig' : 'module.exports'} = {
+  // Default storage types in order of preference
+  defaultStorages: [${config.platforms.includes('web') ? "'indexedDB', 'localStorage'" : "'preferences', 'sqlite'"}, 'memory'],
+  
+  // Platform configuration
+  platform: '${config.platforms[0]}',
+  
+  // Feature flags
+  ${enabledFeatures.includes('encryption') ? `encryption: {
+    enabled: true,
+    algorithm: 'AES-GCM',
+    keyDerivation: {
+      algorithm: 'PBKDF2',
+      iterations: 100000,
+      salt: 32,
+      hash: 'SHA-256'
+    }
+  },` : '// encryption: { enabled: false },'}
+  
+  ${enabledFeatures.includes('compression') ? `compression: {
+    enabled: true,
+    threshold: 1024, // Only compress if larger than 1KB
+    level: 6
+  },` : '// compression: { enabled: false },'}
+  
+  ${enabledFeatures.includes('sync') ? `sync: {
+    enabled: true,
+    debounce: 100,
+    broadcastChannel: 'strata-sync'
+  },` : '// sync: { enabled: false },'}
+  
+  ${enabledFeatures.includes('ttl') ? `ttl: {
+    defaultTTL: 3600000, // 1 hour
+    cleanupInterval: 60000, // 1 minute
+    autoCleanup: true
+  },` : '// ttl: { autoCleanup: false },'}
+  
+  // Adapter-specific configurations
+  adapters: {
+    indexedDB: {
+      database: 'strata-storage',
+      version: 1
+    },
+    sqlite: {
+      database: 'strata.db',
+      location: 'default'
+    },
+    filesystem: {
+      directory: 'strata-data',
+      encoding: 'utf8'
+    }
+  }
+};
+
+${config.typescript ? 'export default config;' : ''}`;
+}
+
+// Generate TypeScript declaration
+function generateTypeDeclaration() {
+  return `/// <reference types="strata-storage" />
+
+declare module 'strata-storage' {
+  // Additional type declarations if needed
+}`;
+}
+
+// Generate example file
+function generateExampleFile(config) {
+  const imports = config.framework === 'react' 
+    ? "import { StrataProvider, useStorage } from 'strata-storage/react';"
+    : config.framework === 'vue'
+    ? "import { useStorage } from 'strata-storage/vue';"
+    : config.framework === 'angular'
+    ? "import { StrataService } from 'strata-storage/angular';"
+    : "import { Strata } from 'strata-storage';";
+  
+  const example = config.framework === 'react' ? `
+// React Example
+function App() {
+  return (
+    <StrataProvider config={config}>
+      <UserProfile />
+    </StrataProvider>
+  );
+}
+
+function UserProfile() {
+  const [user, setUser, loading] = useStorage('user', { name: 'Guest' });
+  
+  if (loading) return <div>Loading...</div>;
+  
+  return (
+    <div>
+      <h1>Hello, {user?.name}!</h1>
+      <button onClick={() => setUser({ name: 'John' })}>
+        Update Name
+      </button>
+    </div>
+  );
+}` : config.framework === 'vue' ? `
+// Vue Example
+export default {
+  setup() {
+    const { value: user, update } = useStorage('user', { name: 'Guest' });
+    
+    const updateName = () => {
+      update({ name: 'John' });
+    };
+    
+    return { user, updateName };
+  }
+}` : config.framework === 'angular' ? `
+// Angular Example
+@Component({
+  selector: 'app-user',
+  template: \`
+    <h1>Hello, {{ (user$ | async)?.name || 'Guest' }}!</h1>
+    <button (click)="updateName()">Update Name</button>
+  \`
+})
+export class UserComponent {
+  user$ = this.strata.watch<{ name: string }>('user');
+  
+  constructor(private strata: StrataService) {}
+  
+  updateName() {
+    this.strata.set('user', { name: 'John' }).subscribe();
+  }
+}` : `
+// Vanilla JS Example
+const storage = new Strata(config);
+
+// Initialize
+await storage.initialize();
+
+// Store data
+await storage.set('user', { name: 'John' });
+
+// Retrieve data
+const user = await storage.get('user');
+console.log(user); // { name: 'John' }
+
+// Subscribe to changes
+storage.subscribe((change) => {
+  console.log('Storage changed:', change);
+});`;
+  
+  return `/**
+ * Strata Storage Example
+ */
+
+${imports}
+import config from './strata.config${config.typescript ? '' : '.js'}';
+${example}`;
+}
+
+// Update .gitignore
+function updateGitignore() {
+  const gitignorePath = '.gitignore';
+  const entries = [
+    '# Strata Storage',
+    'strata-data/',
+    '*.db',
+    '*.db-journal'
+  ];
+  
+  if (fs.existsSync(gitignorePath)) {
+    const content = fs.readFileSync(gitignorePath, 'utf8');
+    const hasStrata = content.includes('# Strata Storage');
+    
+    if (!hasStrata) {
+      fs.appendFileSync(gitignorePath, '\n' + entries.join('\n') + '\n');
+      log.success('Updated .gitignore');
+    }
+  } else {
+    fs.writeFileSync(gitignorePath, entries.join('\n') + '\n');
+    log.success('Created .gitignore');
+  }
+}
+
+// Install dependencies
+async function installDependencies(config) {
+  log.title('Installing dependencies...');
+  
+  const deps = ['strata-storage'];
+  
+  // Add platform-specific dependencies
+  if (config.platforms.includes('ios') || config.platforms.includes('android')) {
+    deps.push('@capacitor/core');
+  }
+  
+  // Install command
+  const command = config.packageManager === 'yarn' 
+    ? `yarn add ${deps.join(' ')}`
+    : config.packageManager === 'pnpm'
+    ? `pnpm add ${deps.join(' ')}`
+    : `npm install ${deps.join(' ')}`;
+  
+  try {
+    log.info(`Running: ${command}`);
+    execSync(command, { stdio: 'inherit' });
+    log.success('Dependencies installed');
+  } catch (error) {
+    log.error('Failed to install dependencies');
+    log.info(`Please run: ${command}`);
+  }
+}
+
+// Show completion message
+function showCompletion(config) {
+  log.title('✨ Configuration complete!');
+  
+  console.log('Next steps:\n');
+  
+  if (config.framework === 'react') {
+    console.log('1. Import StrataProvider in your App component');
+    console.log('2. Wrap your app with <StrataProvider config={config}>');
+    console.log('3. Use hooks like useStorage() in your components');
+  } else if (config.framework === 'vue') {
+    console.log('1. Install the plugin: app.use(StrataPlugin, config)');
+    console.log('2. Use composables like useStorage() in your components');
+  } else if (config.framework === 'angular') {
+    console.log('1. Import StrataModule.forRoot(config) in AppModule');
+    console.log('2. Inject StrataService in your components');
+  } else {
+    console.log('1. Import and initialize Strata with your config');
+    console.log('2. Use storage.set() and storage.get() methods');
+  }
+  
+  console.log('\nSee strata.example.* for a complete example.');
+  console.log('\nDocumentation: https://github.com/aoneahsan/strata-storage');
+}
+
+// Run configuration
+configure().catch((error) => {
+  log.error('Configuration failed:');
+  console.error(error);
+  process.exit(1);
+});

package/scripts/postinstall.js

@@ -0,0 +1,33 @@
+#!/usr/bin/env node
+
+const fs = require('fs');
+const path = require('path');
+
+console.log('\n🚀 Strata Storage - Zero Dependencies, Infinite Possibilities!\n');
+
+// Check if this is a Capacitor project
+const capacitorConfigPaths = [
+  'capacitor.config.json',
+  'capacitor.config.ts',
+  'capacitor.config.js'
+];
+
+const isCapacitorProject = capacitorConfigPaths.some(configPath => 
+  fs.existsSync(path.join(process.cwd(), configPath))
+);
+
+if (isCapacitorProject) {
+  console.log('📱 Capacitor project detected!');
+  console.log('   Run "npx cap sync" to sync native code\n');
+} else {
+  console.log('🌐 Web project detected!');
+  console.log('   Strata works perfectly in web-only projects too!\n');
+}
+
+console.log('📚 Quick Start:');
+console.log('   import { Strata } from "strata-storage";');
+console.log('   const storage = new Strata();');
+console.log('   await storage.set("key", "value");\n');
+
+console.log('📖 Documentation: https://github.com/aoneahsan/strata-storage');
+console.log('⭐ Star us on GitHub: https://github.com/aoneahsan/strata-storage\n');