@stacksjs/storage 0.70.88 → 0.70.90

package/dist/copy.js

@@ -0,0 +1,30 @@
+import { contains } from "@stacksjs/arrays";
+import { join } from "@stacksjs/path";
+import { fs } from "./fs";
+export function copy(src, dest, exclude = []) {
+  if (Array.isArray(src))
+    src.forEach((file) => {
+      copy(file, dest, exclude);
+    });
+  else if (fs.statSync(src).isDirectory())
+    copyFolder(src, dest, exclude);
+  else
+    copyFile(src, dest);
+}
+export function copyFile(src, dest) {
+  fs.copyFileSync(src, dest);
+}
+export function copyFolder(src, dest, exclude = []) {
+  if (!fs.existsSync(dest))
+    fs.mkdirSync(dest, { recursive: !0 });
+  if (fs.existsSync(src))
+    fs.readdirSync(src).forEach((file) => {
+      if (!contains(join(src, file), exclude)) {
+        const srcPath = join(src, file), destPath = join(dest, file);
+        if (fs.statSync(srcPath).isDirectory())
+          copyFolder(srcPath, destPath, exclude);
+        else
+          fs.copyFileSync(srcPath, destPath);
+      }
+    });
+}

package/dist/delete.d.ts

@@ -0,0 +1,8 @@
+import type { Result } from '@stacksjs/error-handling';
+export declare function deleteFolder(path: string): Promise<Result<string, Error>>;
+export declare function isDirectoryEmpty(path: string): Promise<Result<boolean, Error>>;
+export declare function deleteEmptyFolder(path: string): Promise<Result<string, Error>>;
+export declare function deleteEmptyFolders(dir: string): Promise<Result<string, Error>>;
+export declare function deleteFile(path: string): Promise<Result<string, Error>>;
+export declare function deleteGlob(path: string): Promise<Result<string, Error>>;
+export declare function del(path: string): Promise<Result<string, Error>>;

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.d.ts

@@ -0,0 +1,4 @@
+import type { StorageAdapter } from '../types';
+import type { StorageDriver } from '@stacksjs/types';
+export declare function getAwsStorage(): Promise<StorageAdapter>;
+export declare const aws: StorageDriver;

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.d.ts

@@ -0,0 +1,4 @@
+import type { StorageAdapter } from '../types';
+import type { StorageDriver } from '@stacksjs/types';
+export declare function getBunStorage(): Promise<StorageAdapter>;
+export declare const bun: StorageDriver;

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.d.ts

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

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.d.ts

@@ -0,0 +1,4 @@
+import type { StorageAdapter } from '../types';
+import type { StorageDriver } from '@stacksjs/types';
+export declare function getLocalStorage(): Promise<StorageAdapter>;
+export declare const local: StorageDriver;

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.d.ts

@@ -0,0 +1,4 @@
+import type { StorageDriver } from '@stacksjs/types';
+declare const adapter: unknown;
+export declare const memoryStorage: unknown;
+export declare const memory: StorageDriver;

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.d.ts

@@ -0,0 +1,53 @@
+import type { DiskConfig, DiskName, FilesystemConfig, LocalDiskConfig, S3DiskConfig } from './types/filesystem';
+import type { GetStreamOptions, PresignedUploadPolicy, PresignedUploadPolicyOptions, PresignedUploadUrl, PresignedUploadUrlOptions, PutResult, PutStreamOptions, SignedUrlOptions, StatEntry, StorageAdapter } from './types';
+import type { PutFileOptions, UploadedFileLike } from './put-file';
+export type {
+  DiskConfig,
+  FilesystemConfig,
+  LocalDiskConfig,
+  S3DiskConfig,
+} from './types/filesystem';
+// =============================================================================
+// Exports
+// =============================================================================
+export declare const Storage: StorageManager;
+// =============================================================================
+// Storage Manager
+// =============================================================================
+declare class StorageManager {
+  init(config: Partial<FilesystemConfig>): this;
+  disk(name?: DiskName): StorageAdapter;
+  put(path: string, contents: string | Uint8Array | Buffer): Promise<PutResult>;
+  put(file: UploadedFileLike, opts?: PutFileOptions): Promise<PutResult & { url: string }>;
+  put(pathOrFile: string | UploadedFileLike, contentsOrOpts?: string | Uint8Array | Buffer | PutFileOptions): Promise<PutResult | (PutResult & { url: string })>;
+  stat(path: string): Promise<StatEntry>;
+  getStream(path: string, options?: GetStreamOptions): Promise<ReadableStream<Uint8Array>>;
+  putStream(path: string, stream: ReadableStream<Uint8Array>, options?: PutStreamOptions): Promise<PutResult>;
+  copyAcross(source: string, dest: string): Promise<PutResult>;
+  moveAcross(source: string, dest: string): Promise<PutResult>;
+  get(path: string): Promise<string>;
+  exists(path: string): Promise<boolean>;
+  missing(path: string): Promise<boolean>;
+  delete(path: string): Promise<void>;
+  copy(from: string, to: string): Promise<void>;
+  move(from: string, to: string): Promise<void>;
+  url(path: string): Promise<string>;
+  signedUrl(path: string, options: SignedUrlOptions): Promise<string>;
+  presignedUploadUrl(options: PresignedUploadUrlOptions): Promise<PresignedUploadUrl>;
+  presignedUploadPolicy(options: PresignedUploadPolicyOptions): Promise<PresignedUploadPolicy>;
+  size(path: string): Promise<number>;
+  lastModified(path: string): Promise<number>;
+  mimeType(path: string): Promise<string>;
+  checksum(path: string, algorithm?: 'md5' | 'sha1' | 'sha256'): Promise<string>;
+  makeDirectory(path: string): Promise<void>;
+  deleteDirectory(path: string): Promise<void>;
+  files(path?: string): AsyncIterable<{ path: string; type: 'file' | 'directory' }>;
+  allFiles(path?: string): AsyncIterable<{ path: string; type: 'file' | 'directory' }>;
+  configure(name: string, config: DiskConfig): this;
+  setDefaultDisk(name: string): this;
+  getDiskConfig(name?: string): DiskConfig | undefined;
+  getConfiguredDisks(): string[];
+  getDefaultDisk(): string;
+  reset(): this;
+}
+export { StorageManager };