@stacksjs/storage 0.70.87 → 0.70.90

package/dist/delete.js

@@ -0,0 +1,103 @@
+import { italic, log } from "@stacksjs/cli";
+import { err, handleError, ok } from "@stacksjs/error-handling";
+import { join } from "@stacksjs/path";
+import { isFolder } from "./folders";
+import { fs } from "./fs";
+import { glob } from "./glob";
+export function deleteFolder(path) {
+  return new Promise((resolve, reject) => {
+    try {
+      if (isFolder(path)) {
+        fs.rmSync(path, { recursive: !0, force: !0 });
+        return resolve(ok(`Deleted ${path}`));
+      }
+      return resolve(ok(`Path ${path} was not a directory`));
+    } catch (error) {
+      return reject(err(error));
+    }
+  });
+}
+export async function isDirectoryEmpty(path) {
+  return new Promise((resolve, reject) => {
+    try {
+      if (fs.statSync(path).isDirectory()) {
+        if (fs.readdirSync(path).length === 0)
+          return resolve(ok(!0));
+        return resolve(ok(!1));
+      }
+      return resolve(ok(!1));
+    } catch (error) {
+      return reject(err(error));
+    }
+  });
+}
+export async function deleteEmptyFolder(path) {
+  return new Promise((resolve, reject) => {
+    try {
+      if (fs.statSync(path).isDirectory()) {
+        if (fs.readdirSync(path).length === 0) {
+          fs.rmSync(path, { recursive: !0, force: !0 });
+          return resolve(ok(`Deleted ${path}`));
+        }
+        return resolve(ok(`Path ${path} was not empty`));
+      }
+      return resolve(ok(`Path ${path} was not a directory`));
+    } catch (error) {
+      return reject(err(error));
+    }
+  });
+}
+export async function deleteEmptyFolders(dir) {
+  try {
+    if (!fs.existsSync(dir))
+      return ok(`Path ${dir} does not exist`);
+    const files = fs.readdirSync(dir);
+    for (const file of files) {
+      const p = join(dir, file);
+      if (isFolder(p))
+        if (fs.readdirSync(p).length === 0)
+          fs.rmSync(p, { recursive: !0, force: !0 });
+        else
+          await deleteEmptyFolders(p);
+    }
+    return ok(`Deleted empty folders located in ${dir}`);
+  } catch (error) {
+    return err(error);
+  }
+}
+export function deleteFile(path) {
+  return new Promise((resolve, reject) => {
+    try {
+      if (fs.statSync(path).isFile()) {
+        fs.rmSync(path, { recursive: !0, force: !0 });
+        return resolve(ok(`Deleted ${path}`));
+      }
+      return resolve(ok(`Path ${path} was not a file`));
+    } catch (error) {
+      return reject(err(error));
+    }
+  });
+}
+export async function deleteGlob(path) {
+  if (!path.includes("*"))
+    return err(handleError(`Path ${path} does not contain a glob`));
+  const directories = await glob([path], { onlyDirectories: !0 });
+  for (const directory of directories) {
+    const result = await deleteFolder(directory);
+    if (result.isErr) {
+      log.error(result.error);
+      return result;
+    }
+    log.info(`Deleted ${italic(directory)}`);
+  }
+  return ok(`Deleted ${directories.length} directories`);
+}
+export async function del(path) {
+  if (fs.existsSync(path) && fs.statSync(path).isFile())
+    return await deleteFile(path);
+  if (isFolder(path))
+    return await deleteFolder(path);
+  if (path.includes("*"))
+    return await deleteGlob(path);
+  return err(handleError(`Path ${path} cannot be deleted due to an unhandled condition. Please report this issue.`));
+}

package/dist/drivers/aws.js

@@ -0,0 +1,94 @@
+import { createS3Storage } from "../adapters/s3";
+let _adapterPromise = null;
+async function loadConfig() {
+  try {
+    const { filesystems } = await import("@stacksjs/config"), s3Config = filesystems.s3;
+    return createS3Storage(null, {
+      bucket: s3Config?.bucket || "stacks",
+      prefix: s3Config?.prefix || "stx",
+      region: s3Config?.region || "us-east-1"
+    });
+  } catch {
+    const { env } = await import("@stacksjs/env");
+    return createS3Storage(null, {
+      bucket: env.AWS_S3_BUCKET || "stacks",
+      prefix: env.AWS_S3_PREFIX || "stx",
+      region: env.AWS_REGION || "us-east-1"
+    });
+  }
+}
+async function getAdapter() {
+  if (!_adapterPromise)
+    _adapterPromise = loadConfig();
+  return _adapterPromise;
+}
+export async function getAwsStorage() {
+  return getAdapter();
+}
+export const aws = {
+  async write(path, contents) {
+    await (await getAdapter()).write(path, contents);
+  },
+  async deleteFile(path) {
+    await (await getAdapter()).deleteFile(path);
+  },
+  async createDirectory(path) {
+    await (await getAdapter()).createDirectory(path);
+  },
+  async moveFile(from, to) {
+    await (await getAdapter()).moveFile(from, to);
+  },
+  async copyFile(from, to) {
+    await (await getAdapter()).copyFile(from, to);
+  },
+  async stat(path) {
+    return await (await getAdapter()).stat(path);
+  },
+  list(path, options = { deep: !1 }) {
+    return async function* () {
+      yield* (await getAdapter()).list(path, options);
+    }();
+  },
+  async changeVisibility(path, visibility) {
+    await (await getAdapter()).changeVisibility(path, visibility);
+  },
+  async visibility(path) {
+    return await (await getAdapter()).visibility(path);
+  },
+  async fileExists(path) {
+    return await (await getAdapter()).fileExists(path);
+  },
+  async directoryExists(path) {
+    return await (await getAdapter()).directoryExists(path);
+  },
+  async publicUrl(path, options) {
+    return await (await getAdapter()).publicUrl(path, options);
+  },
+  async temporaryUrl(path, options) {
+    return await (await getAdapter()).temporaryUrl(path, options);
+  },
+  async checksum(path, options) {
+    return await (await getAdapter()).checksum(path, options);
+  },
+  async mimeType(path, options) {
+    return await (await getAdapter()).mimeType(path, options);
+  },
+  async lastModified(path) {
+    return await (await getAdapter()).lastModified(path);
+  },
+  async fileSize(path) {
+    return await (await getAdapter()).fileSize(path);
+  },
+  async read(path) {
+    return await (await getAdapter()).read(path);
+  },
+  async readToString(path) {
+    return await (await getAdapter()).readToString(path);
+  },
+  async readToBuffer(path) {
+    return await (await getAdapter()).readToBuffer(path);
+  },
+  async readToUint8Array(path) {
+    return await (await getAdapter()).readToUint8Array(path);
+  }
+};

package/dist/drivers/bun.js

@@ -0,0 +1,88 @@
+import { resolve } from "node:path";
+import process from "node:process";
+import { createBunStorage } from "../adapters/bun";
+let _adapterPromise = null;
+async function loadConfig() {
+  try {
+    const { filesystems } = await import("@stacksjs/config"), rootDirectory = resolve(filesystems.root || process.cwd());
+    return createBunStorage({ root: rootDirectory });
+  } catch {
+    const rootDirectory = resolve(process.cwd());
+    return createBunStorage({ root: rootDirectory });
+  }
+}
+async function getAdapter() {
+  if (!_adapterPromise)
+    _adapterPromise = loadConfig();
+  return _adapterPromise;
+}
+export async function getBunStorage() {
+  return getAdapter();
+}
+export const bun = {
+  async write(path, contents) {
+    await (await getAdapter()).write(path, contents);
+  },
+  async deleteFile(path) {
+    await (await getAdapter()).deleteFile(path);
+  },
+  async createDirectory(path) {
+    await (await getAdapter()).createDirectory(path);
+  },
+  async moveFile(from, to) {
+    await (await getAdapter()).moveFile(from, to);
+  },
+  async copyFile(from, to) {
+    await (await getAdapter()).copyFile(from, to);
+  },
+  async stat(path) {
+    return await (await getAdapter()).stat(path);
+  },
+  list(path, options = { deep: !1 }) {
+    return async function* () {
+      yield* (await getAdapter()).list(path, options);
+    }();
+  },
+  async changeVisibility(path, visibility) {
+    await (await getAdapter()).changeVisibility(path, visibility);
+  },
+  async visibility(path) {
+    return await (await getAdapter()).visibility(path);
+  },
+  async fileExists(path) {
+    return await (await getAdapter()).fileExists(path);
+  },
+  async directoryExists(path) {
+    return await (await getAdapter()).directoryExists(path);
+  },
+  async publicUrl(path, options) {
+    return await (await getAdapter()).publicUrl(path, options);
+  },
+  async temporaryUrl(path, options) {
+    return await (await getAdapter()).temporaryUrl(path, options);
+  },
+  async checksum(path, options) {
+    return await (await getAdapter()).checksum(path, options);
+  },
+  async mimeType(path, options) {
+    return await (await getAdapter()).mimeType(path, options);
+  },
+  async lastModified(path) {
+    return await (await getAdapter()).lastModified(path);
+  },
+  async fileSize(path) {
+    return await (await getAdapter()).fileSize(path);
+  },
+  async read(path) {
+    return await (await getAdapter()).read(path);
+  },
+  async readToString(path) {
+    return await (await getAdapter()).readToString(path);
+  },
+  async readToBuffer(path) {
+    return await (await getAdapter()).readToBuffer(path);
+  },
+  async readToUint8Array(path) {
+    return await (await getAdapter()).readToUint8Array(path);
+  }
+};

package/dist/drivers/index.js

@@ -0,0 +1,4 @@
+export * from "./aws";
+export * from "./local";
+export * from "./memory";
+export * from "./bun";

package/dist/drivers/local.js

@@ -0,0 +1,88 @@
+import { resolve } from "node:path";
+import process from "node:process";
+import { createLocalStorage } from "../adapters/local";
+let _adapterPromise = null;
+async function loadConfig() {
+  try {
+    const { filesystems } = await import("@stacksjs/config"), rootDirectory = resolve(filesystems.root || process.cwd());
+    return createLocalStorage({ root: rootDirectory });
+  } catch {
+    const rootDirectory = resolve(process.cwd());
+    return createLocalStorage({ root: rootDirectory });
+  }
+}
+async function getAdapter() {
+  if (!_adapterPromise)
+    _adapterPromise = loadConfig();
+  return _adapterPromise;
+}
+export async function getLocalStorage() {
+  return getAdapter();
+}
+export const local = {
+  async write(path, contents) {
+    await (await getAdapter()).write(path, contents);
+  },
+  async deleteFile(path) {
+    await (await getAdapter()).deleteFile(path);
+  },
+  async createDirectory(path) {
+    await (await getAdapter()).createDirectory(path);
+  },
+  async moveFile(from, to) {
+    await (await getAdapter()).moveFile(from, to);
+  },
+  async copyFile(from, to) {
+    await (await getAdapter()).copyFile(from, to);
+  },
+  async stat(path) {
+    return await (await getAdapter()).stat(path);
+  },
+  list(path, options = { deep: !1 }) {
+    return async function* () {
+      yield* (await getAdapter()).list(path, options);
+    }();
+  },
+  async changeVisibility(path, visibility) {
+    await (await getAdapter()).changeVisibility(path, visibility);
+  },
+  async visibility(path) {
+    return await (await getAdapter()).visibility(path);
+  },
+  async fileExists(path) {
+    return await (await getAdapter()).fileExists(path);
+  },
+  async directoryExists(path) {
+    return await (await getAdapter()).directoryExists(path);
+  },
+  async publicUrl(path, options) {
+    return await (await getAdapter()).publicUrl(path, options);
+  },
+  async temporaryUrl(path, options) {
+    return await (await getAdapter()).temporaryUrl(path, options);
+  },
+  async checksum(path, options) {
+    return await (await getAdapter()).checksum(path, options);
+  },
+  async mimeType(path, options) {
+    return await (await getAdapter()).mimeType(path, options);
+  },
+  async lastModified(path) {
+    return await (await getAdapter()).lastModified(path);
+  },
+  async fileSize(path) {
+    return await (await getAdapter()).fileSize(path);
+  },
+  async read(path) {
+    return await (await getAdapter()).read(path);
+  },
+  async readToString(path) {
+    return await (await getAdapter()).readToString(path);
+  },
+  async readToBuffer(path) {
+    return await (await getAdapter()).readToBuffer(path);
+  },
+  async readToUint8Array(path) {
+    return await (await getAdapter()).readToUint8Array(path);
+  }
+};

package/dist/drivers/memory.js

@@ -0,0 +1,67 @@
+import { createMemoryStorage } from "../adapters/memory";
+const adapter = createMemoryStorage();
+export const memoryStorage = adapter, memory = {
+  async write(path, contents) {
+    await adapter.write(path, contents);
+  },
+  async deleteFile(path) {
+    await adapter.deleteFile(path);
+  },
+  async createDirectory(path) {
+    await adapter.createDirectory(path);
+  },
+  async moveFile(from, to) {
+    await adapter.moveFile(from, to);
+  },
+  async copyFile(from, to) {
+    await adapter.copyFile(from, to);
+  },
+  async stat(path) {
+    return await adapter.stat(path);
+  },
+  list(path, options = { deep: !1 }) {
+    return adapter.list(path, options);
+  },
+  async changeVisibility(path, visibility) {
+    await adapter.changeVisibility(path, visibility);
+  },
+  async visibility(path) {
+    return await adapter.visibility(path);
+  },
+  async fileExists(path) {
+    return await adapter.fileExists(path);
+  },
+  async directoryExists(path) {
+    return await adapter.directoryExists(path);
+  },
+  async publicUrl(path, options) {
+    return await adapter.publicUrl(path, options);
+  },
+  async temporaryUrl(path, options) {
+    return await adapter.temporaryUrl(path, options);
+  },
+  async checksum(path, options) {
+    return await adapter.checksum(path, options);
+  },
+  async mimeType(path, options) {
+    return await adapter.mimeType(path, options);
+  },
+  async lastModified(path) {
+    return await adapter.lastModified(path);
+  },
+  async fileSize(path) {
+    return await adapter.fileSize(path);
+  },
+  async read(path) {
+    return await adapter.read(path);
+  },
+  async readToString(path) {
+    return await adapter.readToString(path);
+  },
+  async readToBuffer(path) {
+    return await adapter.readToBuffer(path);
+  },
+  async readToUint8Array(path) {
+    return await adapter.readToUint8Array(path);
+  }
+};

package/dist/facade.js

@@ -0,0 +1,226 @@
+import { resolve } from "node:path";
+import process from "node:process";
+import { filesystems, app as appConfig } from "@stacksjs/config";
+import { createLocalStorage } from "./adapters/local";
+import { S3StorageAdapter } from "./adapters/s3";
+import { parseDiskPath } from "./path-sanitize";
+import { putUploadedFile } from "./put-file";
+function buildConfig() {
+  const cwd = process.cwd(), rootDir = filesystems.root || cwd, s3Config = filesystems.s3, appUrl = appConfig?.url || "", config = {
+    default: filesystems.driver || "local",
+    disks: {
+      local: {
+        driver: "local",
+        root: resolve(rootDir, "storage/app"),
+        visibility: filesystems.defaultVisibility || "private"
+      },
+      public: {
+        driver: "local",
+        root: resolve(rootDir, "public"),
+        url: appUrl ? `${appUrl}/storage` : "/storage",
+        visibility: "public"
+      }
+    }
+  };
+  if (s3Config?.bucket)
+    config.disks.s3 = {
+      driver: "s3",
+      bucket: s3Config.bucket,
+      region: s3Config.region || "us-east-1",
+      prefix: s3Config.prefix,
+      endpoint: s3Config.endpoint,
+      url: filesystems.publicUrl?.domain,
+      usePathStyleEndpoint: !!s3Config.endpoint,
+      visibility: filesystems.defaultVisibility || "private",
+      credentials: s3Config.credentials ? { key: s3Config.credentials.accessKeyId, secret: s3Config.credentials.secretAccessKey } : void 0
+    };
+  return config;
+}
+
+class StorageManager {
+  _config = null;
+  disks = new Map;
+  customConfig = null;
+  get config() {
+    if (!this._config) {
+      const builtConfig = buildConfig();
+      this._config = this.customConfig ? {
+        default: this.customConfig.default || builtConfig.default,
+        disks: { ...builtConfig.disks, ...this.customConfig.disks }
+      } : builtConfig;
+    }
+    return this._config;
+  }
+  init(config) {
+    this.customConfig = config;
+    this._config = null;
+    this.disks.clear();
+    return this;
+  }
+  disk(name) {
+    const diskName = name || this.config.default;
+    if (this.disks.has(diskName))
+      return this.disks.get(diskName);
+    const diskConfig = this.config.disks[diskName];
+    if (!diskConfig) {
+      const available = Object.keys(this.config.disks).join(", ");
+      throw Error(`Disk [${diskName}] is not configured. Available: ${available}`);
+    }
+    const adapter = this.createAdapter(diskName, diskConfig);
+    this.disks.set(diskName, adapter);
+    return adapter;
+  }
+  createAdapter(name, config) {
+    switch (config.driver) {
+      case "local":
+        return this.createLocalAdapter(config);
+      case "s3":
+        return this.createS3Adapter(name, config);
+      default:
+        throw Error(`Unsupported driver: ${config.driver}`);
+    }
+  }
+  createLocalAdapter(config) {
+    return createLocalStorage({ root: config.root });
+  }
+  createS3Adapter(_name, config) {
+    return new S3StorageAdapter(null, {
+      bucket: config.bucket,
+      region: config.region,
+      prefix: config.prefix
+    });
+  }
+  async put(pathOrFile, contentsOrOpts) {
+    if (typeof pathOrFile === "string")
+      return this.disk().write(pathOrFile, contentsOrOpts);
+    return putUploadedFile(this, pathOrFile, contentsOrOpts ?? {});
+  }
+  async stat(path) {
+    return this.disk().stat(path);
+  }
+  async getStream(path, options) {
+    const adapter = this.disk();
+    if (typeof adapter.getStream !== "function")
+      throw Error(`[storage] disk '${this.config.default}' does not support getStream \u2014 adapter is missing the optional method`);
+    return adapter.getStream(path, options);
+  }
+  async putStream(path, stream, options) {
+    const adapter = this.disk();
+    if (typeof adapter.putStream !== "function")
+      throw Error(`[storage] disk '${this.config.default}' does not support putStream \u2014 adapter is missing the optional method`);
+    return adapter.putStream(path, stream, options);
+  }
+  async copyAcross(source, dest) {
+    const src = parseDiskPath(source), dst = parseDiskPath(dest);
+    if (src.disk === dst.disk) {
+      const adapter = this.disk(src.disk);
+      await adapter.copyFile(src.path, dst.path);
+      return adapter.stat(dst.path).then((entry) => ({
+        path: dst.path,
+        size: entry.size,
+        contentType: entry.mimeType,
+        lastModified: entry.lastModified
+      }));
+    }
+    const contents = await this.disk(src.disk).read(src.path);
+    return this.disk(dst.disk).write(dst.path, contents);
+  }
+  async moveAcross(source, dest) {
+    const src = parseDiskPath(source), result = await this.copyAcross(source, dest);
+    await this.disk(src.disk).deleteFile(src.path);
+    return result;
+  }
+  async get(path) {
+    return this.disk().readToString(path);
+  }
+  async exists(path) {
+    return this.disk().fileExists(path);
+  }
+  async missing(path) {
+    return !await this.exists(path);
+  }
+  async delete(path) {
+    return this.disk().deleteFile(path);
+  }
+  async copy(from, to) {
+    return this.disk().copyFile(from, to);
+  }
+  async move(from, to) {
+    return this.disk().moveFile(from, to);
+  }
+  async url(path) {
+    return this.disk().publicUrl(path);
+  }
+  async signedUrl(path, options) {
+    const adapter = this.disk();
+    if (typeof adapter.signedUrl !== "function")
+      throw Error(`[storage] disk '${this.config.default}' does not support signedUrl`);
+    return adapter.signedUrl(path, options);
+  }
+  async presignedUploadUrl(options) {
+    const adapter = this.disk();
+    if (typeof adapter.presignedUploadUrl !== "function")
+      throw Error(`[storage] disk '${this.config.default}' does not support presignedUploadUrl \u2014 only S3-style adapters do. Use \`Storage.put(file, opts)\` for local/proxied uploads.`);
+    return adapter.presignedUploadUrl(options);
+  }
+  async presignedUploadPolicy(options) {
+    const adapter = this.disk();
+    if (typeof adapter.presignedUploadPolicy !== "function")
+      throw Error(`[storage] disk '${this.config.default}' does not support presignedUploadPolicy \u2014 S3-only. Use \`presignedUploadUrl\` for the PUT-form, or \`Storage.put(file, opts)\` for server-proxied uploads.`);
+    return adapter.presignedUploadPolicy(options);
+  }
+  async size(path) {
+    return this.disk().fileSize(path);
+  }
+  async lastModified(path) {
+    return this.disk().lastModified(path);
+  }
+  async mimeType(path) {
+    return this.disk().mimeType(path);
+  }
+  async checksum(path, algorithm) {
+    return this.disk().checksum(path, { algorithm });
+  }
+  async makeDirectory(path) {
+    return this.disk().createDirectory(path);
+  }
+  async deleteDirectory(path) {
+    return this.disk().deleteDirectory(path);
+  }
+  files(path = "") {
+    return this.disk().list(path);
+  }
+  allFiles(path = "") {
+    return this.disk().list(path, { deep: !0 });
+  }
+  configure(name, config) {
+    const currentConfig = this.config;
+    currentConfig.disks[name] = config;
+    this.disks.delete(name);
+    return this;
+  }
+  setDefaultDisk(name) {
+    if (!this.config.disks[name])
+      throw Error(`Disk [${name}] is not configured`);
+    this.config.default = name;
+    return this;
+  }
+  getDiskConfig(name) {
+    return this.config.disks[name || this.config.default];
+  }
+  getConfiguredDisks() {
+    return Object.keys(this.config.disks);
+  }
+  getDefaultDisk() {
+    return this.config.default;
+  }
+  reset() {
+    this._config = null;
+    this.customConfig = null;
+    this.disks.clear();
+    return this;
+  }
+}
+export const Storage = new StorageManager;
+
+export { StorageManager };