@seedprotocol/sdk 0.4.6 → 0.4.8

package/dist/Db-C9fppVRl.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"Db-C9fppVRl.js","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/dist/Db-DJAG-5Di.js

@@ -1,345 +0,0 @@
-import { p as BaseDb, y as appState } from './index-Dk73a7JE.js';
-import path from 'path';
-import debug from 'debug';
-import { s as schema } from './index-DBy53qbb.js';
-import fs__default from 'fs';
-import { createClient } from '@libsql/client';
-import { drizzle } from 'drizzle-orm/libsql';
-import { pushSQLiteSchema } from 'drizzle-kit/api';
-import { interval, startWith, switchMap, distinctUntilChanged } from 'rxjs';
-import 'xstate';
-import 'drizzle-orm/sqlite-core';
-import 'drizzle-orm';
-import 'nanoid';
-import 'nanoid-dictionary';
-import 'pluralize';
-import 'ethers';
-import 'lodash-es';
-import 'drizzle-orm/casing';
-import 'eventemitter3';
-import 'arweave';
-import '@sinclair/typebox';
-
-const logger = debug('seedSdk:node:db:Db');
-const getConfig = async (dotSeedDir, config) => {
-    // Create config inline - config values can be passed in or use defaults
-    const drizzleKitMod = await import('drizzle-kit');
-    const { defineConfig } = drizzleKitMod;
-    const appSchemaDir = config?.schemaDir || path.join(dotSeedDir, 'schema');
-    const outDir = config?.outDir || `${dotSeedDir}/db`;
-    const dbUrl = config?.dbUrl || `${dotSeedDir}/db/seed.db`;
-    const nodeDbConfig = defineConfig({
-        schema: appSchemaDir,
-        dialect: 'sqlite',
-        out: outDir,
-        dbCredentials: {
-            url: dbUrl,
-        }
-    });
-    return nodeDbConfig;
-};
-class Db extends BaseDb {
-    constructor() {
-        super();
-    }
-    static getAppDb() {
-        return this.db;
-    }
-    static isAppDbReady() {
-        return true;
-    }
-    static async prepareDb(filesDir, config) {
-        // Resolve and normalize the filesDir path
-        const resolvedFilesDir = path.resolve(filesDir);
-        // Ensure the filesDir exists first (parent directory)
-        if (!fs__default.existsSync(resolvedFilesDir)) {
-            fs__default.mkdirSync(resolvedFilesDir, { recursive: true });
-        }
-        const nodeDbConfig = await getConfig(resolvedFilesDir, config);
-        const dbPath = nodeDbConfig.dbCredentials?.url || path.join(resolvedFilesDir, 'db', 'seed.db');
-        // Ensure the database directory exists
-        const dbDir = path.dirname(dbPath);
-        const dbDirExists = fs__default.existsSync(dbDir);
-        if (!dbDirExists) {
-            fs__default.mkdirSync(dbDir, { recursive: true });
-        }
-        // Use the dbUrl from config if provided, otherwise construct from filesDir
-        const dbUrl = config?.dbUrl
-            ? (config.dbUrl.startsWith('file:') ? config.dbUrl : `file:${path.resolve(config.dbUrl)}`)
-            : `file:${path.resolve(dbPath)}`;
-        const client = createClient({ url: dbUrl });
-        const db = drizzle(client, { schema });
-        const { apply, hasDataLoss, warnings, statementsToExecute } = await pushSQLiteSchema(schema, db);
-        // You can inspect what will happen before applying
-        await apply();
-        this.db = db;
-        // OLD CODE: Resolve better-sqlite3 from project's node_modules first, then fall back to SDK's node_modules
-        // This is important for tests and when the SDK is used as a dependency
-        // const projectDir = path.dirname(filesDir) // filesDir is .seed, so projectDir is the project root
-        // const projectBetterSqlite3Path = path.join(projectDir, 'node_modules', 'better-sqlite3')
-        // 
-        // let Database: any
-        // try {
-        //   const fs = await import('fs')
-        //   if (fs.existsSync(projectBetterSqlite3Path)) {
-        //     // Try to resolve from project's node_modules using the full path
-        //     // For Bun, we can try importing directly from the path
-        //     try {
-        //       // First try using createRequire (works in Node.js)
-        //       const { createRequire } = await import('module')
-        //       const projectRequire = createRequire(path.join(projectDir, 'package.json'))
-        //       const betterSqlite3Module = projectRequire('better-sqlite3')
-        //       Database = betterSqlite3Module.default || betterSqlite3Module
-        //       logger('[node/db/Db] Using better-sqlite3 from project node_modules via createRequire')
-        //     } catch (requireError: any) {
-        //       // If createRequire fails (e.g., in Bun), try direct path import
-        //       logger('[node/db/Db] createRequire failed, trying direct import:', requireError.message)
-        //       const betterSqlite3MainPath = path.join(projectBetterSqlite3Path, 'lib', 'database.js')
-        //       if (fs.existsSync(betterSqlite3MainPath)) {
-        //         // Use dynamic import with the full path
-        //         const betterSqlite3Module = await import(betterSqlite3MainPath)
-        //         Database = betterSqlite3Module.default || betterSqlite3Module.Database || betterSqlite3Module
-        //         logger('[node/db/Db] Using better-sqlite3 from project node_modules via direct import')
-        //       } else {
-        //         throw new Error(`better-sqlite3 main file not found at ${betterSqlite3MainPath}`)
-        //       }
-        //     }
-        //   } else {
-        //     // Fall back to regular import (from SDK's node_modules)
-        //     const betterSqlite3Module = await import('better-sqlite3')
-        //     Database = betterSqlite3Module.default || betterSqlite3Module
-        //     logger('[node/db/Db] Using better-sqlite3 from SDK node_modules')
-        //   }
-        // } catch (importError: any) {
-        //   logger('[node/db/Db] Error importing better-sqlite3:', importError.message)
-        //   logger('[node/db/Db] projectDir:', projectDir)
-        //   logger('[node/db/Db] projectBetterSqlite3Path:', projectBetterSqlite3Path)
-        //   throw new Error(`Failed to import better-sqlite3: ${importError.message}. Please install better-sqlite3 in your project.`)
-        // }
-        // OLD CODE: Create Database instance
-        // const sqlite = new Database(dbPath)
-        // 
-        // OLD CODE: Create drizzle instance with the Database
-        // const {drizzle} = await import('drizzle-orm/better-sqlite3')
-        // this.db = drizzle(sqlite, {
-        //   logger: true,
-        // })
-        // // NEW CODE: Use libsql instead of better-sqlite3
-        // // Resolve @libsql/client from project's node_modules first, then fall back to SDK's node_modules
-        // const projectDir = path.dirname(filesDir) // filesDir is .seed, so projectDir is the project root
-        // const projectLibsqlClientPath = path.join(projectDir, 'node_modules', '@libsql', 'client')
-        // let createClient: any
-        // try {
-        //   const fs = await import('fs')
-        //   if (fs.existsSync(projectLibsqlClientPath)) {
-        //     // Try to resolve from project's node_modules using the full path
-        //     try {
-        //       // First try using createRequire (works in Node.js)
-        //       const { createRequire } = await import('module')
-        //       const projectRequire = createRequire(path.join(projectDir, 'package.json'))
-        //       const libsqlClientModule = projectRequire('@libsql/client')
-        //       createClient = libsqlClientModule.createClient || libsqlClientModule.default?.createClient || libsqlClientModule.default
-        //       logger('[node/db/Db] Using @libsql/client from project node_modules via createRequire')
-        //     } catch (requireError: any) {
-        //       // If createRequire fails, try direct import
-        //       logger('[node/db/Db] createRequire failed, trying direct import:', requireError.message)
-        //       const libsqlClientModule = await import('@libsql/client')
-        //       createClient = libsqlClientModule.createClient
-        //       logger('[node/db/Db] Using @libsql/client from project node_modules via direct import')
-        //     }
-        //   } else {
-        //     // Fall back to regular import (from SDK's node_modules)
-        //     const libsqlClientModule = await import('@libsql/client')
-        //     createClient = libsqlClientModule.createClient
-        //     logger('[node/db/Db] Using @libsql/client from SDK node_modules')
-        //   }
-        // } catch (importError: any) {
-        //   logger('[node/db/Db] Error importing @libsql/client:', importError.message)
-        //   logger('[node/db/Db] projectDir:', projectDir)
-        //   logger('[node/db/Db] projectLibsqlClientPath:', projectLibsqlClientPath)
-        //   throw new Error(`Failed to import @libsql/client: ${importError.message}. Please install @libsql/client in your project.`)
-        // }
-        // // Convert file path to file: URL for libsql
-        // // If dbPath is already a file: URL, use it as is, otherwise convert it
-        // const dbUrl = dbPath.startsWith('file:') ? dbPath : `file:${path.resolve(dbPath)}`
-        // // Create libsql client instance
-        // const client = createClient({ url: dbUrl })
-        // // Create drizzle instance with the libsql client
-        // const {drizzle} = await import('drizzle-orm/libsql')
-        // this.db = drizzle(client, {
-        //   logger: true,
-        // })
-        // if (!this.db) {
-        //   throw new Error('Db not found')
-        // }
-        return this.db;
-    }
-    static async connectToDb(pathToDir) {
-        return {
-            id: this.db ? this.db.constructor.name : ''
-        };
-    }
-    static async migrate(pathToDbDir, dbName, dbId) {
-        const fs = await import('fs');
-        const path = await import('path');
-        // Ensure meta directory and _journal.json exist
-        const metaDir = path.join(pathToDbDir, 'meta');
-        const journalPath = path.join(metaDir, '_journal.json');
-        try {
-            if (!fs.existsSync(metaDir)) {
-                fs.mkdirSync(metaDir, { recursive: true });
-            }
-            // Create a minimal _journal.json if it doesn't exist
-            if (!fs.existsSync(journalPath)) {
-                const minimalJournal = {
-                    version: "7",
-                    dialect: "sqlite",
-                    entries: []
-                };
-                fs.writeFileSync(journalPath, JSON.stringify(minimalJournal, null, 2));
-                logger('Created minimal _journal.json file');
-            }
-            else {
-                // Verify the journal file is valid JSON
-                try {
-                    const journalContent = fs.readFileSync(journalPath, 'utf-8');
-                    const journal = JSON.parse(journalContent);
-                    if (!journal.dialect || !journal.version) {
-                        // Fix invalid journal
-                        const fixedJournal = {
-                            version: journal.version || "7",
-                            dialect: journal.dialect || "sqlite",
-                            entries: journal.entries || []
-                        };
-                        fs.writeFileSync(journalPath, JSON.stringify(fixedJournal, null, 2));
-                        logger('Fixed invalid _journal.json file');
-                    }
-                }
-                catch (parseError) {
-                    // If journal is invalid, recreate it
-                    const minimalJournal = {
-                        version: "7",
-                        dialect: "sqlite",
-                        entries: []
-                    };
-                    fs.writeFileSync(journalPath, JSON.stringify(minimalJournal, null, 2));
-                    logger('Recreated corrupted _journal.json file');
-                }
-            }
-        }
-        catch (error) {
-            logger('Warning: Could not create meta/_journal.json:', error.message);
-            // Continue anyway - the migrator might handle it
-        }
-        try {
-            if (!this.db) {
-                throw new Error('Database not initialized. Call prepareDb first.');
-            }
-            // OLD CODE: const {migrate} = await import('drizzle-orm/better-sqlite3/migrator')
-            // migrationsFolder should point to the directory containing migration SQL files
-            // In drizzle-kit, migrations are generated in the 'out' directory (which is pathToDbDir)
-            // migrate(this.db, { migrationsFolder: pathToDbDir })
-            // NEW CODE: Use libsql migrator
-            const migratorMod = await import('drizzle-orm/libsql/migrator');
-            const { migrate } = migratorMod;
-            // migrationsFolder should point to the directory containing migration SQL files
-            // In drizzle-kit, migrations are generated in the 'out' directory (which is pathToDbDir)
-            await migrate(this.db, { migrationsFolder: pathToDbDir });
-            const queryResult = await this.db.select().from(appState);
-            logger('queryResult', queryResult);
-        }
-        catch (error) {
-            // Handle various migration errors gracefully in test environments
-            const errorMessage = error.message || String(error) || '';
-            const errorString = String(error);
-            const isMigrationError = errorMessage.includes("Can't find meta/_journal.json") ||
-                errorMessage.includes('_journal.json') ||
-                errorMessage.includes("Cannot read properties of undefined") ||
-                errorMessage.includes("reading 'dialect'") ||
-                errorMessage.includes("undefined is not an object") ||
-                errorString.includes("dialect") ||
-                errorString.includes("undefined is not an object");
-            if (isMigrationError) {
-                if (process.env.NODE_ENV === 'test' || process.env.IS_SEED_DEV) {
-                    logger('Warning: Migration failed, but continuing in test environment:', errorMessage || errorString);
-                    // Try to query the database anyway to see if it's usable
-                    try {
-                        if (this.db) {
-                            const queryResult = await this.db.select().from(appState);
-                            logger('Database is accessible despite migration error');
-                            return this.db;
-                        }
-                    }
-                    catch (queryError) {
-                        logger('Database query also failed, but continuing in test environment');
-                        return this.db;
-                    }
-                }
-            }
-            throw error;
-        }
-        return this.db;
-    }
-    /**
-     * Execute a reactive query that emits new results whenever the underlying data changes.
-     *
-     * NOTE: This is a stub implementation using polling. For production use, consider enhancing
-     * with database triggers, change streams, or other real-time mechanisms.
-     *
-     * Currently supports Drizzle query builders. SQL tag functions are not supported in node
-     * environment (use browser implementation for SQL tag functions).
-     *
-     * @param query - Drizzle query builder (SQL tag functions not supported in node)
-     * @returns Observable that emits arrays of query results
-     *
-     * @example
-     * ```typescript
-     * import { models } from '@/seedSchema'
-     * import { eq } from 'drizzle-orm'
-     *
-     * const appDb = Db.getAppDb()
-     * const models$ = Db.liveQuery<ModelRow>(
-     *   appDb.select().from(models).where(eq(models.schemaFileId, schemaId))
-     * )
-     *
-     * models$.subscribe(models => {
-     *   console.log('Models updated:', models)
-     * })
-     * ```
-     */
-    static liveQuery(query) {
-        if (!this.db) {
-            throw new Error('Database not initialized. Call prepareDb first.');
-        }
-        // Polling interval (configurable, default: 1000ms)
-        const pollInterval = 1000;
-        // Check if query is a function (SQL tag function) - not supported in node stub
-        if (typeof query === 'function') {
-            throw new Error('SQL tag functions are not supported in node liveQuery stub implementation. Use Drizzle query builders instead.');
-        }
-        // For Drizzle query builders, we need to execute them
-        // Store the query builder for polling
-        const queryBuilder = query;
-        return interval(pollInterval).pipe(startWith(0), // Execute immediately on subscription
-        switchMap(async () => {
-            try {
-                // Execute the Drizzle query builder
-                // Drizzle query builders return promises when executed
-                const result = await Promise.resolve(queryBuilder);
-                return result;
-            }
-            catch (error) {
-                logger('[Db.liveQuery] Error executing query:', error);
-                throw error;
-            }
-        }), distinctUntilChanged((prev, curr) => {
-            // Only emit if results actually changed
-            // Use JSON.stringify for deep comparison
-            return JSON.stringify(prev) === JSON.stringify(curr);
-        }));
-    }
-}
-BaseDb.setPlatformClass(Db);
-
-export { Db };
-//# sourceMappingURL=Db-DJAG-5Di.js.map

package/dist/Db-DJAG-5Di.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"Db-DJAG-5Di.js","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/dist/EasClient-DQGAIj-b.js

@@ -1,29 +0,0 @@
-import { w as BaseEasClient, E as EAS_ENDPOINT } from './index-Dk73a7JE.js';
-import { GraphQLClient } from 'graphql-request';
-import 'xstate';
-import 'drizzle-orm/sqlite-core';
-import 'drizzle-orm';
-import 'nanoid';
-import 'nanoid-dictionary';
-import 'debug';
-import 'pluralize';
-import 'ethers';
-import 'rxjs';
-import 'lodash-es';
-import 'drizzle-orm/casing';
-import 'eventemitter3';
-import 'arweave';
-import '@sinclair/typebox';
-
-class EasClient extends BaseEasClient {
-    static getEasClient() {
-        if (!this.easClient) {
-            this.easClient = new GraphQLClient(EAS_ENDPOINT);
-        }
-        return this.easClient;
-    }
-}
-BaseEasClient.setPlatformClass(EasClient);
-
-export { EasClient };
-//# sourceMappingURL=EasClient-DQGAIj-b.js.map

package/dist/EasClient-DQGAIj-b.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"EasClient-DQGAIj-b.js","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/dist/EasClient-T7Nx9185.js

@@ -1,29 +0,0 @@
-import { w as BaseEasClient, E as EAS_ENDPOINT } from './index-Dk73a7JE.js';
-import { GraphQLClient } from 'graphql-request';
-import 'xstate';
-import 'drizzle-orm/sqlite-core';
-import 'drizzle-orm';
-import 'nanoid';
-import 'nanoid-dictionary';
-import 'debug';
-import 'pluralize';
-import 'ethers';
-import 'rxjs';
-import 'lodash-es';
-import 'drizzle-orm/casing';
-import 'eventemitter3';
-import 'arweave';
-import '@sinclair/typebox';
-
-class EasClient extends BaseEasClient {
-    static getEasClient() {
-        if (!this.easClient) {
-            this.easClient = new GraphQLClient(EAS_ENDPOINT);
-        }
-        return this.easClient;
-    }
-}
-BaseEasClient.setPlatformClass(EasClient);
-
-export { EasClient };
-//# sourceMappingURL=EasClient-T7Nx9185.js.map

package/dist/EasClient-T7Nx9185.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"EasClient-T7Nx9185.js","sources":[],"sourcesContent":[],"names":[],"mappings":""}