@stacksjs/storage 0.58.48 → 0.58.49

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@stacksjs/storage",
   "type": "module",
-  "version": "0.58.48",
+  "version": "0.58.49",
   "description": "The Stacks file system.",
   "author": "Chris Breuer",
   "license": "MIT",
@@ -42,7 +42,8 @@
   ],
   "files": [
     "README.md",
-    "dist"
+    "dist",
+    "src"
   ],
   "scripts": {
     "build": "bun --bun build.ts",

package/src/copy.ts

@@ -0,0 +1,42 @@
+import { contains } from '@stacksjs/arrays'
+import { join } from '@stacksjs/path'
+import { fs } from './fs'
+
+export function copy(src: string | string[], dest: string, exclude: string[] = []): void {
+  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: string, dest: string): void {
+  fs.copyFileSync(src, dest)
+}
+
+export function copyFolder(src: string, dest: string, exclude: string[] = []): void {
+  if (!fs.existsSync(dest))
+    fs.mkdirSync(dest, { recursive: true })
+
+  if (fs.existsSync(src)) {
+    fs.readdirSync(src).forEach((file) => {
+      if (!contains(join(src, file), exclude)) {
+        const srcPath = join(src, file)
+        const destPath = join(dest, file)
+
+        if (fs.statSync(srcPath).isDirectory())
+          copyFolder(srcPath, destPath, exclude)
+
+        else
+          fs.copyFileSync(srcPath, destPath)
+      }
+    })
+  }
+}

package/src/delete.ts

@@ -0,0 +1,131 @@
+import type { Result } from '@stacksjs/error-handling'
+import { err, ok } from '@stacksjs/error-handling'
+import { italic, log } from '@stacksjs/cli'
+import { isFile } from './files'
+import { isFolder } from './folders'
+import { glob } from './glob'
+import { fs } from './fs'
+
+export function deleteFolder(path: string): Promise<Result<string, Error>> {
+  return new Promise((resolve, reject) => {
+    try {
+      if (isFolder(path)) {
+        fs.rmSync(path, { recursive: true, force: true })
+        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: string): Promise<Result<boolean, Error>> {
+  return new Promise((resolve, reject) => {
+    try {
+      if (fs.statSync(path).isDirectory()) {
+        if (fs.readdirSync(path).length === 0)
+          return resolve(ok(true))
+        else
+          return resolve(ok(false))
+      }
+
+      return resolve(ok(false))
+    }
+    catch (error) {
+      return reject(err(error))
+    }
+  })
+}
+
+export async function deleteEmptyFolder(path: string): Promise<Result<string, Error>> {
+  return new Promise((resolve, reject) => {
+    try {
+      if (fs.statSync(path).isDirectory()) {
+        if (fs.readdirSync(path).length === 0) {
+          fs.rmSync(path, { recursive: true, force: true })
+          return resolve(ok(`Deleted ${path}`))
+        }
+        else { 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: string): Promise<Result<string, Error>> {
+  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: true, force: true })
+        else
+          await deleteEmptyFolders(p)
+      }
+    }
+
+    return ok(`Deleted empty folders located in ${dir}`)
+  }
+  catch (error: any) {
+    return err(error)
+  }
+}
+
+export function deleteFile(path: string): Promise<Result<string, Error>> {
+  return new Promise((resolve, reject) => {
+    try {
+      if (isFile(path)) {
+        fs.rmSync(path, { recursive: true, force: true })
+        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: string): Promise<Result<string, Error>> {
+  if (!path.includes('*'))
+    return err(handleError(`Path ${path} does not contain a glob`))
+
+  const directories = await glob([path], { onlyDirectories: true })
+
+  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: string): Promise<Result<string, Error>> {
+  if (isFile(path))
+    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/src/drivers/aws.ts

@@ -0,0 +1,15 @@
+import type { NestedStackProps } from 'aws-cdk-lib'
+import { NestedStack } from 'aws-cdk-lib'
+import type { Construct } from 'constructs'
+
+export class StorageStack extends NestedStack {
+  constructor(scope: Construct, id: string, props?: NestedStackProps) {
+    super(scope, id, props)
+
+    // if (!storage.name)
+    //   throw new Error('./config storage.name is not defined')
+
+    // // eslint-disable-next-line no-new
+    // new s3.Bucket(this, storage.name)
+  }
+}

package/src/drivers/index.ts

@@ -0,0 +1 @@
+export * as aws from './aws'

package/src/files.ts

@@ -0,0 +1,190 @@
+import type { BunFile, PathLike } from 'bun'
+import type { JsonFile, PackageJson, TextFile } from '@stacksjs/types'
+import { detectIndent, detectNewline } from '@stacksjs/strings'
+import { dirname, join, path as p } from '@stacksjs/path'
+import { contains } from '@stacksjs/arrays'
+import { existsSync, fs } from './fs'
+
+/**
+ * Reads a JSON file and returns the parsed data.
+ */
+export async function readJsonFile(name: string, cwd?: string): Promise<JsonFile> {
+  const file = await readTextFile(name, cwd)
+  const data = JSON.parse(file.data)
+  const indent = detectIndent(file.data).indent
+  const newline = detectNewline(file.data)
+
+  return { ...file, data, indent, newline }
+}
+
+/**
+ * Reads a package.json file and returns the parsed data.
+ */
+export async function readPackageJson(name: string, cwd?: string) {
+  const file = await readJsonFile(name, cwd)
+  return file.data as PackageJson
+}
+
+type Path = BunFile | PathLike
+type Data = Blob | TypedArray | ArrayBufferLike | string | BlobPart[]
+
+/**
+ * Writes the given text to the specified file.
+ */
+export async function writeFile(path: Path, data: Data): Promise<number> {
+  if (typeof path === 'string') {
+    const dirPath = dirname(path)
+    if (!await existsSync(dirPath))
+      await createFolder(dirPath)
+
+    return await Bun.write(Bun.file(path), data)
+  }
+
+  return await Bun.write(path, data)
+}
+
+/**
+ * Writes the given data to the specified JSON file.
+ */
+export async function writeJsonFile(file: JsonFile): Promise<number> {
+  let json = JSON.stringify(file.data, undefined, file.indent)
+
+  if (file.newline)
+    json += file.newline
+
+  return writeTextFile({ ...file, data: json })
+}
+
+/**
+ * Reads a text file and returns its contents.
+ */
+export function readTextFile(name: string, cwd?: string): Promise<TextFile> {
+  return new Promise((resolve, reject) => {
+    let filePath: string
+
+    if (cwd)
+      filePath = join(cwd, name)
+    else
+      filePath = name
+
+    fs.readFile(filePath, 'utf8', (err, text) => {
+      if (err) {
+        reject(err)
+      }
+      else {
+        resolve({
+          path: filePath,
+          data: text,
+        })
+      }
+    })
+  })
+}
+
+/**
+ * Writes the given text to the specified file.
+ */
+export async function writeTextFile(file: TextFile): Promise<number> {
+  return await Bun.write(file.path, file.data)
+}
+
+/**
+ * Determine whether a path exists.
+ */
+export function isFile(path: string): boolean {
+  return fs.existsSync(path)
+}
+
+export function doesExist(path: string): boolean {
+  return !isFile(path) || !isFolder(path)
+}
+
+export function doesNotExist(path: string): boolean {
+  return !isFile(path) && !isFolder(path)
+}
+
+/**
+ * Determine whether a folder has any files in it.
+ */
+export function hasFiles(folder: string): boolean {
+  try {
+    return fs.readdirSync(folder).length > 0
+  }
+  catch (err) {
+    return false
+  }
+}
+
+export function hasComponents(): boolean {
+  return hasFiles(p.componentsPath())
+}
+
+export function hasFunctions(): boolean {
+  return hasFiles(p.functionsPath())
+}
+
+export function deleteFiles(dir: string, exclude: string[] = []) {
+  if (fs.existsSync(dir)) {
+    fs.readdirSync(dir).forEach((file) => {
+      const p = join(dir, file)
+      if (fs.statSync(p).isDirectory()) {
+        if (fs.readdirSync(p).length === 0)
+          fs.rmSync(p, { recursive: true, force: true })
+
+        else
+          deleteFiles(p, exclude)
+      }
+
+      else if (!contains(p, exclude)) {
+        fs.rmSync(p)
+      }
+    })
+  }
+}
+
+export function getFiles(dir: string, exclude: string[] = []): string[] {
+  let results: string[] = []
+  const list = fs.readdirSync(dir)
+
+  list.forEach((file) => {
+    file = join(dir, file)
+    const stat = fs.statSync(file)
+
+    if (stat && stat.isDirectory())
+      results = results.concat(getFiles(file, exclude))
+
+    else if (!contains(file, exclude))
+      results.push(file)
+  })
+
+  return results
+}
+
+export function put(path: string, contents: string) {
+  const dirPath = dirname(path)
+
+  if (!fs.existsSync(dirPath))
+    fs.mkdirSync(dirPath, { recursive: true })
+
+  fs.writeFileSync(path, contents, 'utf-8')
+}
+
+export async function get(path: string): Promise<string> {
+  return Bun.file(path).text()
+}
+
+export const files = {
+  readJsonFile,
+  readPackageJson,
+  readTextFile,
+  writeJsonFile,
+  writeTextFile,
+  isFile,
+  hasFiles,
+  hasComponents,
+  hasFunctions,
+  deleteFiles,
+  getFiles,
+  put,
+  get,
+}

package/src/folders.ts

@@ -0,0 +1,51 @@
+import { join } from '@stacksjs/path'
+import { fs } from './fs'
+
+/**
+ * Determine whether a path is a folder.
+ */
+export function isFolder(path: string): boolean {
+  try {
+    return fs.statSync(path).isDirectory()
+  }
+  catch {
+    return false
+  }
+}
+
+export function isDirectory(path: string): boolean {
+  return isFolder(path)
+}
+
+export function isDir(path: string): boolean {
+  return isFolder(path)
+}
+
+export function doesFolderExist(path: string) {
+  return fs.existsSync(path)
+}
+
+export function createFolder(dir: string): Promise<void> {
+  return new Promise((resolve, reject) => {
+    fs.mkdirs(dir, (err: any) => {
+      if (err)
+        reject(err)
+
+      else
+        resolve()
+    })
+  })
+}
+
+export function getFolders(dir: string): string[] {
+  return fs.readdirSync(dir).filter((file) => {
+    return fs.statSync(join(dir, file)).isDirectory()
+  })
+}
+
+export const folders = {
+  isFolder,
+  doesFolderExist,
+  createFolder,
+  getFolders,
+}

package/src/fs.ts

@@ -0,0 +1,9 @@
+import { mkdirSync, writeFileSync } from 'node:fs'
+import * as fs from 'fs-extra'
+import { pathExists as existsSync } from 'fs-extra'
+
+export async function exists(path: string): Promise<boolean> {
+  return await existsSync(path)
+}
+
+export { fs, existsSync, mkdirSync, writeFileSync }

package/src/glob.ts

@@ -0,0 +1 @@
+export { default as glob } from 'fast-glob'

package/src/hash.ts

@@ -0,0 +1,39 @@
+import type { Hash } from 'node:crypto'
+import { createHash } from 'node:crypto'
+import { path as p } from '@stacksjs/path'
+import { fs } from './fs'
+
+export function hashFileOrDirectory(path: string, hash: Hash): void {
+  if (fs.statSync(path).isDirectory()) {
+    const files = fs.readdirSync(path)
+    for (const file of files) {
+      const filePath = p.join(path, file)
+      hashFileOrDirectory(filePath, hash)
+    }
+  }
+  else {
+    hash.update(fs.readFileSync(path))
+  }
+}
+
+export function hashDirectory(directory: string): string {
+  const hash = createHash('sha256')
+  hashFileOrDirectory(directory, hash)
+  return hash.digest('hex')
+}
+
+export function hashPath(path: string): string {
+  const hash = createHash('sha256')
+  hashFileOrDirectory(path, hash)
+  return hash.digest('hex')
+}
+
+export function hashPaths(paths: string | string[]): string {
+  const hash = createHash('sha256')
+  const pathsArray = Array.isArray(paths) ? paths : [paths]
+
+  for (const path of pathsArray)
+    hashFileOrDirectory(path, hash)
+
+  return hash.digest('hex')
+}

package/src/helpers.ts

@@ -0,0 +1,29 @@
+import { fileURLToPath } from 'node:url'
+import { dirname } from '@stacksjs/path'
+import { fs } from './fs'
+
+export const _dirname = typeof __dirname !== 'undefined'
+  ? __dirname
+  : dirname(fileURLToPath(import.meta.url))
+
+export function updateConfigFile(filePath: string, newConfig: Record<string, unknown>): Promise<void> {
+  return new Promise((resolve, reject) => {
+    const config = JSON.parse(fs.readFileSync(filePath, 'utf8')) as Record<string, unknown>
+
+    for (const key in newConfig)
+      config[key] = newConfig[key]
+
+    try {
+      fs.writeFileSync(filePath, JSON.stringify(config, null, 2))
+      resolve()
+    }
+    catch (error) {
+      reject(error)
+    }
+  })
+}
+
+export const helpers = {
+  _dirname,
+  updateConfigFile,
+}

package/src/index.ts

@@ -0,0 +1,11 @@
+export * from './files'
+export * from './folders'
+export * from './hash'
+export * from './helpers'
+export * from './fs'
+export * from './copy'
+export * from './glob'
+export * from './delete'
+export * from './zip'
+
+export * as storage from './storage'

package/src/move.ts

@@ -0,0 +1,84 @@
+import { type Result, err, ok } from '@stacksjs/error-handling'
+import { log } from '@stacksjs/logging'
+import { path } from '@stacksjs/path'
+import { fs } from './fs'
+
+interface MoveOptions {
+  // glob?: glob.Options
+  overwrite?: boolean
+}
+
+export async function move(
+  src: string | string[],
+  dest: string,
+  options?: MoveOptions,
+): Promise<Result<{ message: string }, Error>> {
+  try {
+    if (Array.isArray(src)) {
+      const operations = src.map(async (file) => {
+        const from = file
+        const to = path.resolve(dest, path.basename(file))
+        const result = await rename(from, to, options)
+
+        if (result.isErr()) {
+          log.error(result.error)
+          return err(handleError(result.error.message, result.error))
+        }
+      })
+
+      await Promise.all(operations)
+
+      return ok({ message: 'Files moved successfully' })
+    }
+
+    const from = src
+    const to = dest
+    const result = await rename(from, to, options)
+
+    if (result.isErr()) {
+      log.error(result.error)
+      return err(handleError(result.error))
+    }
+
+    return ok({ message: 'File moved successfully' })
+  }
+  catch (error: any) {
+    return err(handleError(error))
+  }
+}
+
+export async function rename(from: string, to: string, options?: MoveOptions): Promise<Result<{ message: string }, Error>> {
+  return new Promise((resolve, reject) => {
+    try {
+      // Check if the "to" directory exists
+      const dir = path.dirname(to)
+      if (!fs.existsSync(dir))
+        fs.mkdirSync(dir, { recursive: true })
+
+      // Ensure the "from" file exists
+      if (!fs.existsSync(from))
+        return reject(err(new Error(`File or directory does not exist: ${from}`)))
+
+      // Ensure the "to" file does not exist
+      if (fs.existsSync(to)) {
+        if (!options?.overwrite)
+          return reject(err(new Error(`File or directory already exists: ${to}`)))
+
+        fs.unlinkSync(to)
+      }
+
+      // "Move" the file
+      fs.renameSync(from, to)
+
+      return resolve(ok({ message: 'File moved successfully' }))
+    }
+    catch (error: any) {
+      if (error.code === 'ENOENT')
+        log.error('File or directory does not exist\n\n', error)
+      else
+        log.error(error)
+
+      return reject(err(new Error(error)))
+    }
+  })
+}

package/src/storage.ts

@@ -0,0 +1,10 @@
+export * from './files'
+export * from './folders'
+export * from './helpers'
+export * from './fs'
+
+export * from './copy'
+export * from './delete'
+export * from './move'
+export * from './zip'
+export * from './visibility'

package/src/visibility.ts

@@ -0,0 +1,6 @@
+// type Visibility = 'public' | 'private'
+
+// export function setVisibility(path: string, visibility: Visibility) {
+export function setVisibility() {
+  return 'wip'
+}

package/src/zip.ts

@@ -0,0 +1,55 @@
+import type { ZlibCompressionOptions } from 'bun'
+import { runCommand } from '@stacksjs/cli'
+
+interface ZipOptions {
+  cwd?: string
+}
+
+export async function zip(from: string | string[], to?: string, options?: ZipOptions) {
+  const toPath = to || 'archive.zip'
+  const fromPath = Array.isArray(from) ? from.join(' ') : from
+
+  if (Array.isArray(from))
+    return runCommand(`zip -r ${toPath} ${fromPath}`, options)
+
+  return runCommand(`zip -r ${to} ${from}`, options)
+}
+
+export async function unzip(paths: string | string[]) {
+  if (Array.isArray(paths))
+    return runCommand(`unzip ${paths.join(' ')}`)
+
+  return runCommand(`unzip ${paths}`)
+}
+
+export function archive(paths: string | string[]) {
+  return zip(paths)
+}
+
+export function unarchive(paths: string | string[]) {
+  return unzip(paths)
+}
+
+export function compress(paths: string[]) {
+  return zip(paths)
+}
+
+export function decompress(paths: string | string[]) {
+  return unzip(paths)
+}
+
+export function gzipSync(data: Uint8Array, options?: ZlibCompressionOptions) {
+  return Bun.gzipSync(data, options) // buffer extends Uint8Array
+}
+
+export function gunzipSync(data: Uint8Array) {
+  return Bun.gunzipSync(data) // decompressed
+}
+
+export function deflateSync(data: Uint8Array, options?: ZlibCompressionOptions) {
+  return Bun.deflateSync(data, options) // compressed
+}
+
+export function inflateSync(data: Uint8Array) {
+  return Bun.inflateSync(data) // decompressed
+}