@farm.js/core 0.1.16 → 0.1.18

package/dist/storage.cjs

@@ -1,576 +1,57 @@
-"use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/storage/index.ts
-var storage_exports = {};
-__export(storage_exports, {
-  createFarmStorage: () => createFarmStorage,
-  createStorageClient: () => createStorageClient,
-  databaseStorage: () => databaseStorage,
-  defineStorageClient: () => defineStorageClient,
-  disposeStorage: () => disposeStorage,
-  driverStorage: () => driverStorage,
-  getStorage: () => getStorage,
-  initStorage: () => initStorage,
-  libsqlStorage: () => libsqlStorage,
-  localStorage: () => localStorage,
-  memoryStorage: () => memoryStorage,
-  mongodbStorage: () => mongodbStorage,
-  mysql2Storage: () => mysql2Storage,
-  mysqlStorage: () => mysqlStorage,
-  netlifyBlobsStorage: () => netlifyBlobsStorage,
-  pgStorage: () => pgStorage,
-  pgliteStorage: () => pgliteStorage,
-  planetscaleStorage: () => planetscaleStorage,
-  postgresStorage: () => postgresStorage,
-  redisStorage: () => redisStorage,
-  resolveStorageRuntimeClient: () => resolveStorageRuntimeClient,
-  s3Storage: () => s3Storage,
-  sqliteStorage: () => sqliteStorage,
-  upstashStorage: () => upstashStorage,
-  vercelBlobStorage: () => vercelBlobStorage,
-  vercelKVStorage: () => vercelKVStorage
-});
-module.exports = __toCommonJS(storage_exports);
-var import_unstorage = require("unstorage");
-var import_memory = __toESM(require("unstorage/drivers/memory"));
-var loadModule = /* @__PURE__ */ __name((specifier) => import(
-  /* @vite-ignore */
-  specifier
-), "loadModule");
-var DATABASE_CONNECTORS = {
-  sqlite: {
-    connector: "node-sqlite",
-    load: /* @__PURE__ */ __name(() => loadModule("db0/connectors/node-sqlite"), "load")
-  },
-  "node-sqlite": {
-    connector: "node-sqlite",
-    load: /* @__PURE__ */ __name(() => loadModule("db0/connectors/node-sqlite"), "load")
-  },
-  sqlite3: {
-    connector: "sqlite3",
-    load: /* @__PURE__ */ __name(() => loadModule("db0/connectors/sqlite3"), "load")
-  },
-  "better-sqlite3": {
-    connector: "better-sqlite3",
-    load: /* @__PURE__ */ __name(() => loadModule("db0/connectors/better-sqlite3"), "load")
-  },
-  postgres: {
-    connector: "postgresql",
-    load: /* @__PURE__ */ __name(() => loadModule("db0/connectors/postgresql"), "load")
-  },
-  postgresql: {
-    connector: "postgresql",
-    load: /* @__PURE__ */ __name(() => loadModule("db0/connectors/postgresql"), "load")
-  },
-  pg: {
-    connector: "postgresql",
-    load: /* @__PURE__ */ __name(() => loadModule("db0/connectors/postgresql"), "load")
-  },
-  mysql: {
-    connector: "mysql2",
-    load: /* @__PURE__ */ __name(() => loadModule("db0/connectors/mysql2"), "load")
-  },
-  mysql2: {
-    connector: "mysql2",
-    load: /* @__PURE__ */ __name(() => loadModule("db0/connectors/mysql2"), "load")
-  },
-  pglite: {
-    connector: "pglite",
-    load: /* @__PURE__ */ __name(() => loadModule("db0/connectors/pglite"), "load")
-  },
-  planetscale: {
-    connector: "planetscale",
-    load: /* @__PURE__ */ __name(() => loadModule("db0/connectors/planetscale"), "load")
-  },
-  libsql: {
-    connector: "libsql",
-    load: /* @__PURE__ */ __name(() => loadModule("db0/connectors/libsql/node"), "load")
-  },
-  "libsql-node": {
-    connector: "libsql-node",
-    load: /* @__PURE__ */ __name(() => loadModule("db0/connectors/libsql/node"), "load")
-  },
-  "libsql-http": {
-    connector: "libsql-http",
-    load: /* @__PURE__ */ __name(() => loadModule("db0/connectors/libsql/http"), "load")
-  }
-};
-function createMemoryStorage() {
-  return (0, import_unstorage.createStorage)({
-    driver: (0, import_memory.default)()
-  });
-}
-__name(createMemoryStorage, "createMemoryStorage");
-var GLOBAL_STORAGE_KEY = /* @__PURE__ */ Symbol.for("farmjs.storage.global");
-function readGlobalStorage() {
-  return globalThis[GLOBAL_STORAGE_KEY];
-}
-__name(readGlobalStorage, "readGlobalStorage");
-function writeGlobalStorage(storage) {
-  globalThis[GLOBAL_STORAGE_KEY] = storage;
-  return storage;
-}
-__name(writeGlobalStorage, "writeGlobalStorage");
-function getActiveGlobalStorage() {
-  const existing = readGlobalStorage();
-  if (existing) {
-    return existing;
-  }
-  return writeGlobalStorage(createMemoryStorage());
-}
-__name(getActiveGlobalStorage, "getActiveGlobalStorage");
-var globalStorage = getActiveGlobalStorage();
-function normalizeMountKey(base) {
-  return (base || "").trim().replace(/^[:/\\]+|[:/\\]+$/g, "").replace(/[\\/]+/g, ":");
-}
-__name(normalizeMountKey, "normalizeMountKey");
-function isDriverInstance(value) {
-  return !!value && typeof value === "object" && typeof value.getItem === "function" && typeof value.getKeys === "function";
-}
-__name(isDriverInstance, "isDriverInstance");
-function isStorageInstance(value) {
-  return !!value && typeof value === "object" && typeof value.mount === "function" && typeof value.getMount === "function";
-}
-__name(isStorageInstance, "isStorageInstance");
-function isStorageClient(value) {
-  return !!value && typeof value === "object" && value.kind === "farm-storage-client" && typeof value.resolveDriver === "function" && typeof value.createStorage === "function";
-}
-__name(isStorageClient, "isStorageClient");
-function isDatabaseDriverName(name) {
-  return name in DATABASE_CONNECTORS;
-}
-__name(isDatabaseDriverName, "isDatabaseDriverName");
-function extractDriverOptions(config) {
-  const source = config;
-  const {
-    client: _client,
-    driver: _driver,
-    mounts: _mounts,
-    options,
-    tableName: _tableName,
-    ...inlineOptions
-  } = source;
-  const hasInlineOptions = Object.keys(inlineOptions).length > 0;
-  if (options && typeof options === "object" && !Array.isArray(options)) {
-    return hasInlineOptions ? { ...inlineOptions, ...options } : options;
-  }
-  if (hasInlineOptions) {
-    return inlineOptions;
-  }
-  return options;
-}
-__name(extractDriverOptions, "extractDriverOptions");
-async function loadBuiltinDriver(name, options) {
-  const modulePath = import_unstorage.builtinDrivers[name];
-  if (!modulePath) {
-    throw new Error(`Unsupported storage driver "${name}".`);
-  }
-  const module2 = await loadModule(modulePath);
-  return module2.default(options);
-}
-__name(loadBuiltinDriver, "loadBuiltinDriver");
-async function loadDatabaseDriver(config) {
-  const connectorEntry = DATABASE_CONNECTORS[config.driver];
-  const [{ createDatabase }, connectorModule, db0DriverModule] = await Promise.all([
-    loadModule("db0"),
-    connectorEntry.load(),
-    loadModule("unstorage/drivers/db0")
-  ]);
-  const database = createDatabase(connectorModule.default(extractDriverOptions(config) || {}));
-  const driver = db0DriverModule.default({
-    database,
-    tableName: config.tableName
-  });
-  return {
-    ...driver,
-    async dispose() {
-      await database.dispose();
-    }
-  };
-}
-__name(loadDatabaseDriver, "loadDatabaseDriver");
-async function resolveDriver(config) {
-  if (config && isStorageClient(config)) {
-    return config.resolveDriver();
-  }
-  const driverInput = config?.driver ?? "memory";
-  if (typeof driverInput === "function") {
-    return await driverInput();
-  }
-  if (isDriverInstance(driverInput)) {
-    return driverInput;
-  }
-  if (isDatabaseDriverName(driverInput)) {
-    return loadDatabaseDriver(config);
-  }
-  if (driverInput === "local") {
-    return loadBuiltinDriver("fs-lite", extractDriverOptions(config));
-  }
-  return loadBuiltinDriver(
-    driverInput,
-    extractDriverOptions(config)
-  );
-}
-__name(resolveDriver, "resolveDriver");
-function createStorageClientFromResolver(resolveDriver2) {
-  let driverPromise;
-  let storagePromise;
-  const ensureDriver = /* @__PURE__ */ __name(() => {
-    if (driverPromise) return driverPromise;
-    const pending = Promise.resolve().then(resolveDriver2);
-    driverPromise = pending;
-    void pending.catch(() => {
-      if (driverPromise === pending) {
-        driverPromise = void 0;
-        storagePromise = void 0;
-      }
-    });
-    return pending;
-  }, "ensureDriver");
-  const ensureStorage = /* @__PURE__ */ __name(() => {
-    if (storagePromise) return storagePromise;
-    const pending = ensureDriver().then(
-      (driver) => (0, import_unstorage.createStorage)({
-        driver
-      })
-    );
-    storagePromise = pending;
-    void pending.catch(() => {
-      if (storagePromise === pending) storagePromise = void 0;
-    });
-    return pending;
-  }, "ensureStorage");
-  const target = {
-    kind: "farm-storage-client",
-    ready: ensureStorage,
-    createStorage: ensureStorage,
-    resolveDriver: ensureDriver
-  };
-  return new Proxy(target, {
-    get(currentTarget, prop, receiver) {
-      if (prop === "then") {
-        return void 0;
-      }
-      if (Reflect.has(currentTarget, prop)) {
-        return Reflect.get(currentTarget, prop, receiver);
-      }
-      return (...args) => ensureStorage().then(async (storage) => {
-        const member = Reflect.get(storage, prop);
-        if (typeof member !== "function") {
-          return member;
-        }
-        const result = Reflect.apply(member, storage, args);
-        if (prop === "dispose") {
-          return Promise.resolve(result).finally(() => {
-            storagePromise = void 0;
-            driverPromise = void 0;
-          });
-        }
-        return result;
-      });
-    }
-  });
-}
-__name(createStorageClientFromResolver, "createStorageClientFromResolver");
-function defineStorageClient(resolveDriver2) {
-  return createStorageClientFromResolver(resolveDriver2);
-}
-__name(defineStorageClient, "defineStorageClient");
-function createStorageClient(config) {
-  return defineStorageClient(() => resolveDriver(config));
-}
-__name(createStorageClient, "createStorageClient");
-function driverStorage(driver) {
-  return defineStorageClient(() => typeof driver === "function" ? driver() : driver);
-}
-__name(driverStorage, "driverStorage");
-function databaseStorage(database, options = {}) {
-  return defineStorageClient(async () => {
-    const db0DriverModule = await loadModule("unstorage/drivers/db0");
-    const { dispose: _dispose, ...driver } = db0DriverModule.default({
-      database,
-      tableName: options.tableName
-    });
-    return driver;
-  });
-}
-__name(databaseStorage, "databaseStorage");
-function memoryStorage() {
-  return createStorageClient({ driver: "memory" });
-}
-__name(memoryStorage, "memoryStorage");
-function localStorage(options = {}) {
-  return createStorageClient({
-    driver: "local",
-    ...options
-  });
-}
-__name(localStorage, "localStorage");
-function sqliteStorage(options) {
-  return createStorageClient({
-    driver: "sqlite",
-    ...options
-  });
-}
-__name(sqliteStorage, "sqliteStorage");
-function mysqlStorage(options) {
-  return createStorageClient({
-    driver: "mysql",
-    ...options
-  });
-}
-__name(mysqlStorage, "mysqlStorage");
-function mysql2Storage(options) {
-  return mysqlStorage(options);
-}
-__name(mysql2Storage, "mysql2Storage");
-function postgresStorage(options) {
-  return createStorageClient({
-    driver: "postgres",
-    ...options
-  });
-}
-__name(postgresStorage, "postgresStorage");
-function pgStorage(options) {
-  return postgresStorage(options);
-}
-__name(pgStorage, "pgStorage");
-function pgliteStorage(options) {
-  return createStorageClient({
-    driver: "pglite",
-    ...options
-  });
-}
-__name(pgliteStorage, "pgliteStorage");
-function planetscaleStorage(options) {
-  return createStorageClient({
-    driver: "planetscale",
-    ...options
-  });
-}
-__name(planetscaleStorage, "planetscaleStorage");
-function libsqlStorage(options) {
-  return createStorageClient({
-    driver: "libsql",
-    ...options
-  });
-}
-__name(libsqlStorage, "libsqlStorage");
-function redisStorage(options) {
-  return createStorageClient({
-    driver: "redis",
-    ...options
-  });
-}
-__name(redisStorage, "redisStorage");
-function s3Storage(options) {
-  return createStorageClient({
-    driver: "s3",
-    ...options
-  });
-}
-__name(s3Storage, "s3Storage");
-function mongodbStorage(options) {
-  return createStorageClient({
-    driver: "mongodb",
-    ...options
-  });
-}
-__name(mongodbStorage, "mongodbStorage");
-function upstashStorage(options) {
-  return createStorageClient({
-    driver: "upstash",
-    ...options
-  });
-}
-__name(upstashStorage, "upstashStorage");
-function netlifyBlobsStorage(options) {
-  return createStorageClient({
-    driver: "netlify-blobs",
-    ...options
-  });
-}
-__name(netlifyBlobsStorage, "netlifyBlobsStorage");
-function vercelKVStorage(options) {
-  return createStorageClient({
-    driver: "vercel-kv",
-    ...options
-  });
-}
-__name(vercelKVStorage, "vercelKVStorage");
-function vercelBlobStorage(options) {
-  return createStorageClient({
-    driver: "vercel-blob",
-    ...options
-  });
-}
-__name(vercelBlobStorage, "vercelBlobStorage");
-async function mountNamespaces(storage, mounts) {
-  if (!mounts) {
-    return;
-  }
-  for (const [base, config] of Object.entries(mounts)) {
-    storage.mount(normalizeMountKey(base), await resolveDriver(config));
-  }
-}
-__name(mountNamespaces, "mountNamespaces");
-async function createFarmStorage(config = {}) {
-  if (isStorageInstance(config)) {
-    return config;
-  }
-  if (isStorageClient(config)) {
-    return config.createStorage();
-  }
-  const rootConfig = isStorageClient(config.client) ? config.client : config;
-  const storage = (0, import_unstorage.createStorage)({
-    driver: await resolveDriver(rootConfig)
-  });
-  try {
-    await mountNamespaces(storage, config.mounts);
-  } catch (error) {
-    await storage.dispose().catch(() => {
-    });
-    throw error;
-  }
-  return storage;
-}
-__name(createFarmStorage, "createFarmStorage");
-async function resolveStorageRuntimeClient(config) {
-  if (!config || isStorageInstance(config) || isStorageClient(config)) {
-    return void 0;
-  }
-  const client = config.client;
-  if (!client || isStorageInstance(client) || isStorageClient(client)) {
-    return void 0;
-  }
-  return typeof client === "function" ? await client() : client;
-}
-__name(resolveStorageRuntimeClient, "resolveStorageRuntimeClient");
-async function initStorage(config = {}) {
-  globalStorage = getActiveGlobalStorage();
-  const nextStorage = await createFarmStorage(config);
-  const previousStorage = globalStorage;
-  globalStorage = writeGlobalStorage(nextStorage);
-  if (previousStorage !== nextStorage) {
-    await previousStorage.dispose().catch(() => {
-    });
-  }
-  return globalStorage;
-}
-__name(initStorage, "initStorage");
-function getStorage(namespace) {
-  globalStorage = getActiveGlobalStorage();
-  const base = normalizeMountKey(namespace);
-  if (!base) {
-    return globalStorage;
-  }
-  const namespaced = (0, import_unstorage.prefixStorage)(globalStorage, base);
-  const store = globalStorage;
-  const prefix = `${base}:`;
-  const stripPrefix = /* @__PURE__ */ __name((key) => key.startsWith(prefix) ? key.slice(prefix.length) : key, "stripPrefix");
-  const viewUnwatchers = /* @__PURE__ */ new Set();
-  const releaseViewWatchers = /* @__PURE__ */ __name(async () => {
-    const current = [...viewUnwatchers];
-    viewUnwatchers.clear();
-    await Promise.all(current.map((unwatch) => unwatch()));
-  }, "releaseViewWatchers");
-  return {
-    ...namespaced,
-    // Scope the wipe to the namespace instead of the whole storage, and keep
-    // the caller's base so `clear("sessions")` cannot take unrelated keys with
-    // it. Dropping the argument silently widens a targeted clear into a
-    // namespace-wide delete.
-    async clear(base2, opts) {
-      const keys = await namespaced.getKeys(base2);
-      await Promise.all(keys.map((key) => namespaced.removeItem(key, opts)));
-    },
-    async watch(callback) {
-      const unwatch = await store.watch((event, key) => {
-        if (key.startsWith(prefix)) callback(event, stripPrefix(key));
-      });
-      viewUnwatchers.add(unwatch);
-      return async () => {
-        viewUnwatchers.delete(unwatch);
-        await unwatch();
-      };
-    },
-    async unwatch() {
-      await releaseViewWatchers();
-    },
-    async dispose() {
-      await releaseViewWatchers();
-    },
-    getMount(key = "") {
-      return store.getMount(prefix + key);
-    },
-    getMounts(base2 = "", options) {
-      return store.getMounts(prefix + base2, options).map((mount) => ({ ...mount, base: stripPrefix(mount.base) }));
-    }
-  };
-}
-__name(getStorage, "getStorage");
-async function disposeStorage() {
-  globalStorage = getActiveGlobalStorage();
-  const previousStorage = globalStorage;
-  globalStorage = writeGlobalStorage(createMemoryStorage());
-  await previousStorage.dispose().catch(() => {
-  });
-}
-__name(disposeStorage, "disposeStorage");
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  createFarmStorage,
-  createStorageClient,
-  databaseStorage,
-  defineStorageClient,
-  disposeStorage,
-  driverStorage,
-  getStorage,
-  initStorage,
-  libsqlStorage,
-  localStorage,
-  memoryStorage,
-  mongodbStorage,
-  mysql2Storage,
-  mysqlStorage,
-  netlifyBlobsStorage,
-  pgStorage,
-  pgliteStorage,
-  planetscaleStorage,
-  postgresStorage,
-  redisStorage,
-  resolveStorageRuntimeClient,
-  s3Storage,
-  sqliteStorage,
-  upstashStorage,
-  vercelBlobStorage,
-  vercelKVStorage
-});
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+var _chunk4ZFL5GFNcjs = require('./chunk-4ZFL5GFN.cjs');
+require('./chunk-S3JO3N4H.cjs');
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.createFarmStorage = _chunk4ZFL5GFNcjs.createFarmStorage; exports.createStorageClient = _chunk4ZFL5GFNcjs.createStorageClient; exports.databaseStorage = _chunk4ZFL5GFNcjs.databaseStorage; exports.defineStorageClient = _chunk4ZFL5GFNcjs.defineStorageClient; exports.disposeStorage = _chunk4ZFL5GFNcjs.disposeStorage; exports.driverStorage = _chunk4ZFL5GFNcjs.driverStorage; exports.getStorage = _chunk4ZFL5GFNcjs.getStorage; exports.initStorage = _chunk4ZFL5GFNcjs.initStorage; exports.libsqlStorage = _chunk4ZFL5GFNcjs.libsqlStorage; exports.localStorage = _chunk4ZFL5GFNcjs.localStorage; exports.memoryStorage = _chunk4ZFL5GFNcjs.memoryStorage; exports.mongodbStorage = _chunk4ZFL5GFNcjs.mongodbStorage; exports.mysql2Storage = _chunk4ZFL5GFNcjs.mysql2Storage; exports.mysqlStorage = _chunk4ZFL5GFNcjs.mysqlStorage; exports.netlifyBlobsStorage = _chunk4ZFL5GFNcjs.netlifyBlobsStorage; exports.pgStorage = _chunk4ZFL5GFNcjs.pgStorage; exports.pgliteStorage = _chunk4ZFL5GFNcjs.pgliteStorage; exports.planetscaleStorage = _chunk4ZFL5GFNcjs.planetscaleStorage; exports.postgresStorage = _chunk4ZFL5GFNcjs.postgresStorage; exports.redisStorage = _chunk4ZFL5GFNcjs.redisStorage; exports.resolveStorageRuntimeClient = _chunk4ZFL5GFNcjs.resolveStorageRuntimeClient; exports.s3Storage = _chunk4ZFL5GFNcjs.s3Storage; exports.sqliteStorage = _chunk4ZFL5GFNcjs.sqliteStorage; exports.upstashStorage = _chunk4ZFL5GFNcjs.upstashStorage; exports.vercelBlobStorage = _chunk4ZFL5GFNcjs.vercelBlobStorage; exports.vercelKVStorage = _chunk4ZFL5GFNcjs.vercelKVStorage;