@sequencemedia/drive 0.0.0

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "@sequencemedia/drive",
+  "version": "0.0.0",
+  "main": "./src/index.mjs",
+  "type": "module",
+  "types": "./src/index.d.mts",
+  "author": {
+    "name": "Jonathan Perry for Sequence Media Limited",
+    "email": "sequencemedia@sequencemedia.net",
+    "url": "https://sequencemedia.net"
+  },
+  "license": "ISC",
+  "scripts": {
+    "lint": "eslint .",
+    "lint:fix": "npm run lint -- --fix",
+    "prepare": "husky"
+  },
+  "dependencies": {
+    "debug": "^4.3.7",
+    "googleapis": "^144.0.0",
+    "nconf": "^0.12.1"
+  },
+  "devDependencies": {
+    "@babel/core": "^7.26.0",
+    "@babel/preset-env": "^7.26.0",
+    "@sequencemedia/eslint-config-standard": "^0.1.4",
+    "@sequencemedia/eslint-config-typescript": "^0.0.2",
+    "@types/debug": "^4.1.12",
+    "@types/nconf": "^0.10.7",
+    "@types/node": "^22.10.1",
+    "core-js": "^3.39.0",
+    "eslint": "^9.16.0",
+    "globals": "^15.13.0",
+    "husky": "^9.1.7"
+  },
+  "imports": {
+    "#common": "./src/common/index.mjs",
+    "#common/*": "./src/common/*.mjs"
+  },
+  "exports": {
+    "./create": "./src/create/index.mjs",
+    "./delete": "./src/delete/index.mjs",
+    "./get": "./src/get/index.mjs",
+    "./get-list": "./src/get-list/index.mjs"
+  }
+}

package/src/common/authorize.d.mts

@@ -0,0 +1,10 @@
+import type { JWT } from 'google-auth-library'
+
+export function getClientEmail (keyFile: KeyFileType): string | null
+
+export function getPrivateKey (keyFile: KeyFileType): string | null
+
+/**
+ * Authorise using a Service Account (and return a JWT client)
+ */
+export default function authorize (keyFile: KeyFileType, scopes?: string[]): Promise<JWT>

package/src/common/authorize.mjs

@@ -0,0 +1,41 @@
+/**
+ * @typedef {import('google-auth-library').JWT} JWT
+ */
+
+import {
+  google
+} from 'googleapis'
+
+export function getClientEmail ({
+  client_email: clientEmail = null
+}) {
+  return clientEmail
+}
+
+export function getPrivateKey ({
+  private_key: privateKey = null
+}) {
+  return privateKey
+}
+
+/**
+ * Authorise using a Service Account (and return a JWT client)
+ *
+ * @param {Record<PropertyKey, string | undefined>} keyFile
+ * @param {string[]} scopes
+ * @returns {JWT}
+ */
+export default async function authorize (keyFile, scopes = []) {
+  if (!keyFile) throw new Error('A key file is required')
+
+  const authClient = new google.auth.JWT(
+    getClientEmail(keyFile),
+    null,
+    getPrivateKey(keyFile),
+    scopes
+  )
+
+  await authClient.authorize()
+
+  return authClient
+}

package/src/common/config.d.mts

@@ -0,0 +1,13 @@
+declare const config: Record<PropertyKey, string | undefined>
+
+declare const KEY_FILE_JSON: string | undefined
+declare const KEY_FILE_PATH: string | undefined
+declare const GOOGLE_DRIVE_VERSION: string
+
+export default config
+
+export {
+  KEY_FILE_JSON,
+  KEY_FILE_PATH,
+  GOOGLE_DRIVE_VERSION
+}

package/src/common/config.mjs

@@ -0,0 +1,21 @@
+import nconf from 'nconf'
+
+const config = nconf.argv().env().defaults({
+  KEY_FILE_JSON: null,
+  KEY_FILE_PATH: null,
+  GOOGLE_DRIVE_VERSION: 'v3'
+}).get()
+
+const {
+  KEY_FILE_JSON,
+  KEY_FILE_PATH,
+  GOOGLE_DRIVE_VERSION
+} = config
+
+export default config
+
+export {
+  KEY_FILE_JSON,
+  KEY_FILE_PATH,
+  GOOGLE_DRIVE_VERSION
+}

package/src/common/error.d.mts

@@ -0,0 +1,15 @@
+export function hasErrorCode ({ code }: {
+  code: number | undefined
+}): boolean
+
+export function getErrorCode ({ code }: {
+  code: number | undefined
+}): number | undefined
+
+export function hasErrorMessage ({ message }: {
+  message: string | undefined
+}): boolean
+
+export function getErrorMessage ({ message }: {
+  message: string | undefined
+}): string | undefined

package/src/common/error.mjs

@@ -0,0 +1,15 @@
+export function hasErrorCode ({ code }) {
+  return Boolean(code)
+}
+
+export function getErrorCode ({ code }) {
+  return code
+}
+
+export function hasErrorMessage ({ message }) {
+  return Boolean(message)
+}
+
+export function getErrorMessage ({ message }) {
+  return message
+}

package/src/common/getKeyFile.d.mts

@@ -0,0 +1,16 @@
+import {
+  KEY_FILE_JSON,
+  KEY_FILE_PATH
+} from '#common/config'
+
+/**
+ * @param {string | undefined | null} keyFileJson
+ * @param {string | undefined | null} keyFilePath
+ * @returns {Promise<KeyFileType>}
+ */
+export default function getKeyFile (keyFileJson: string | undefined | null, keyFilePath: string | undefined | null): Promise<KeyFileType>
+
+export {
+  KEY_FILE_JSON,
+  KEY_FILE_PATH
+}

package/src/common/getKeyFile.mjs

@@ -0,0 +1,39 @@
+import {
+  readFile
+} from 'node:fs/promises'
+
+import {
+  KEY_FILE_JSON,
+  KEY_FILE_PATH
+} from '#common/config'
+
+import hasKeyFileJson from './hasKeyFileJson.mjs'
+import hasKeyFilePath from './hasKeyFilePath.mjs'
+
+export {
+  KEY_FILE_JSON,
+  KEY_FILE_PATH
+}
+
+/**
+ * @param {string | undefined | null} keyFileJson
+ * @param {string | undefined | null} keyFilePath
+ * @returns {Promise<Record<PropertyKey, string | undefined>>}
+ */
+export default async function getKeyFile (keyFileJson, keyFilePath) {
+  if (hasKeyFileJson(keyFileJson)) {
+    return (
+      JSON.parse(
+        keyFileJson
+      )
+    )
+  }
+
+  if (await hasKeyFilePath(keyFilePath)) {
+    return (
+      JSON.parse(
+        await readFile(keyFilePath)
+      )
+    )
+  }
+}

package/src/common/hasKeyFile.d.mts

@@ -0,0 +1,16 @@
+import {
+  KEY_FILE_JSON,
+  KEY_FILE_PATH
+} from '#common/config'
+
+/**
+ * @param {string | undefined | null} keyFileJson
+ * @param {string | undefined | null} keyFilePath
+ * @returns {Promise<boolean>}
+ */
+export default function hasKeyFile (keyFileJson: string | undefined | null, keyFilePath: string | undefined | null): Promise<boolean>
+
+export {
+  KEY_FILE_JSON,
+  KEY_FILE_PATH
+}

package/src/common/hasKeyFile.mjs

@@ -0,0 +1,27 @@
+import {
+  KEY_FILE_JSON,
+  KEY_FILE_PATH
+} from '#common/config'
+
+import hasKeyFileJson from './hasKeyFileJson.mjs'
+import hasKeyFilePath from './hasKeyFilePath.mjs'
+
+export {
+  KEY_FILE_JSON,
+  KEY_FILE_PATH
+}
+
+/**
+ * @param {string | undefined | null} keyFileJson
+ * @param {string | undefined | null} keyFilePath
+ * @returns {Promise<boolean>}
+ */
+export default async function hasKeyFile (keyFileJson, keyFilePath) {
+  try {
+    if (hasKeyFileJson(keyFileJson)) return true
+    if (hasKeyFilePath(keyFilePath)) return true
+    return false
+  } catch {
+    return false
+  }
+}

package/src/common/hasKeyFileJson.d.mts

@@ -0,0 +1,5 @@
+/**
+ * @param {string | undefined | null} keyFileJson
+ * @returns {boolean}
+ */
+export default function hasKeyFileJson (keyFileJson: string | undefined | null): boolean

package/src/common/hasKeyFileJson.mjs

@@ -0,0 +1,12 @@
+/**
+ * @param {string | undefined | null} keyFileJson
+ * @returns {boolean}
+ */
+export default function hasKeyFileJson (keyFileJson = null) {
+  try {
+    if (keyFileJson && JSON.parse(keyFileJson)) return true
+    return false
+  } catch {
+    return false
+  }
+}

package/src/common/hasKeyFilePath.d.mts

@@ -0,0 +1,5 @@
+/**
+ * @param {string | undefined | null} keyFilePath
+ * @returns {Promise<boolean>}
+ */
+export default function hasKeyFilePath (keyFilePath: string | undefined | null): Promise<boolean>

package/src/common/hasKeyFilePath.mjs

@@ -0,0 +1,20 @@
+import {
+  constants,
+  access
+} from 'node:fs/promises'
+
+/**
+ * @param {string | undefined | null} keyFilePath
+ * @returns {Promise<boolean>}
+ */
+export default async function hasKeyFilePath (keyFilePath = null) {
+  try {
+    if (keyFilePath) {
+      await access(keyFilePath, constants.R_OK)
+      return true
+    }
+    return false
+  } catch {
+    return false
+  }
+}

package/src/create/index.d.mts

@@ -0,0 +1,10 @@
+/**
+ * Create a JSON file in Google Drive
+ */
+export default function createInDrive (
+  driveId: string,
+  fileName: string,
+  fileData: Buffer,
+  keyFile: KeyFileType,
+  scopes?: string[]
+): Promise<FileType>

package/src/create/index.mjs

@@ -0,0 +1,102 @@
+/**
+ * @typedef {import('google-auth-library').OAuth2Client} AuthClient
+ * @typedef {import('googleapis').drive_v3 } DriveV3
+ * @typedef {DriveV3.Schema$File} File
+ */
+
+import debug from 'debug'
+
+import {
+  Readable
+} from 'node:stream'
+
+import {
+  google
+} from 'googleapis'
+
+import {
+  GOOGLE_DRIVE_VERSION
+} from '#common/config'
+
+import {
+  hasErrorCode,
+  getErrorCode,
+  getErrorMessage
+} from '#common/error'
+
+import authorize from '#common/authorize'
+
+const SCOPES = [
+  'https://www.googleapis.com/auth/drive.file'
+]
+
+const log = debug('@sequencemedia/drive/create')
+const error = debug('@sequencemedia/drive/create:error')
+
+log('`@sequencemedia/drive` is awake')
+
+/**
+ * Create a JSON file in Google Drive
+ *
+ * @param {string} driveId Drive identifier
+ * @param {string} fileName JSON file identifier
+ * @param {string} fileData JSON file contents
+ * @param {AuthClient} authClient An authorised OAuth2 client
+ * @returns {File}
+ */
+async function createJsonFile (driveId, fileName, fileData, authClient) {
+  try {
+    const drive = google.drive({
+      version: GOOGLE_DRIVE_VERSION,
+      auth: authClient
+    })
+
+    const {
+      data
+    } = await drive.files.create({
+      supportsAllDrives: true,
+      // includeItemsFromAllDrives: true,
+      requestBody: {
+        fields: 'id, name',
+        parents: [
+          driveId
+        ],
+        name: fileName
+      },
+      media: {
+        mimeType: 'application/json',
+        body: Readable.from(Buffer.from(fileData))
+      }
+    })
+
+    return data
+  } catch (e) {
+    if (hasErrorCode(e)) error(getErrorCode(e))
+    error(getErrorMessage(e))
+    throw e
+  }
+}
+
+/**
+ * Create a JSON file in Google Drive
+ *
+ * @param {string} driveId Drive identifier
+ * @param {string} fileName JSON file name
+ * @param {Buffer} fileData JSON file data
+ * @param {Record<PropertyKey, string | undefined>} keyFile Authorisation
+ * @param {string[]} scopes Authorisation scopes
+ * @returns {File}
+ */
+export default async function createInDrive (driveId, fileName, fileData, keyFile, scopes = SCOPES) {
+  return (
+    await createJsonFile(
+      driveId,
+      fileName,
+      fileData.toString('utf8'),
+      await authorize(
+        keyFile,
+        scopes
+      )
+    )
+  )
+}

package/src/delete/index.d.mts

@@ -0,0 +1,8 @@
+/**
+ * Delete a JSON file from Google Drive
+ */
+export default function deleteFromDrive (
+  fileId: string,
+  keyFile: KeyFileType,
+  scopes?: string[]
+): Promise<void>

package/src/delete/index.mjs

@@ -0,0 +1,75 @@
+/**
+ * @typedef {import('google-auth-library').OAuth2Client} AuthClient
+ */
+
+import debug from 'debug'
+
+import {
+  google
+} from 'googleapis'
+
+import {
+  GOOGLE_DRIVE_VERSION
+} from '#common/config'
+
+import {
+  hasErrorCode,
+  getErrorCode,
+  getErrorMessage
+} from '#common/error'
+
+import authorize from '#common/authorize'
+
+const SCOPES = [
+  'https://www.googleapis.com/auth/drive.file'
+]
+
+const log = debug('@sequencemedia/drive/delete')
+const error = debug('@sequencemedia/drive/delete:error')
+
+log('`@sequencemedia/drive` is awake')
+
+/**
+ * Delete a JSON file from Google Drive
+ *
+ * @param {string} fileId JSON file identifier
+ * @param {AuthClient} authClient An authorised OAuth2 client
+ * @returns {Promise<void>}
+ */
+async function deleteJsonFile (fileId, authClient) {
+  try {
+    const drive = google.drive({
+      version: GOOGLE_DRIVE_VERSION,
+      auth: authClient
+    })
+
+    await drive.files.delete({
+      supportsAllDrives: true,
+      // includeItemsFromAllDrives: true,
+      fileId
+    })
+  } catch (e) {
+    if (hasErrorCode(e)) error(getErrorCode(e))
+    error(getErrorMessage(e))
+    throw e
+  }
+}
+
+/**
+ * Delete a JSON file from Google Drive
+ *
+ * @param {string} fileId JSON file identifier
+ * @param {Record<PropertyKey, string | undefined>} keyFile An authorised OAuth2 client
+ * @returns {Promise<void>}
+ */
+export default async function deleteFromDrive (fileId, keyFile, scopes = SCOPES) {
+  return (
+    await deleteJsonFile(
+      fileId,
+      await authorize(
+        keyFile,
+        scopes
+      )
+    )
+  )
+}

package/src/get/index.d.mts

@@ -0,0 +1,8 @@
+/**
+ * Get a JSON file from Google Drive
+ */
+export default function getFromDrive (
+  fileId: string,
+  keyFile: KeyFileType,
+  scopes?: string[]
+): Promise<FileType>

package/src/get/index.mjs

@@ -0,0 +1,81 @@
+/**
+ * @typedef {import('google-auth-library').OAuth2Client} AuthClient
+ * @typedef {import('googleapis').drive_v3 } DriveV3
+ * @typedef {DriveV3.Schema$File} File
+ */
+
+import debug from 'debug'
+
+import {
+  google
+} from 'googleapis'
+
+import {
+  GOOGLE_DRIVE_VERSION
+} from '#common/config'
+
+import {
+  hasErrorCode,
+  getErrorCode,
+  getErrorMessage
+} from '#common/error'
+
+import authorize from '#common/authorize'
+
+const SCOPES = [
+  'https://www.googleapis.com/auth/drive.file'
+]
+
+const log = debug('@sequencemedia/drive/get')
+const error = debug('@sequencemedia/drive/get:error')
+
+log('`@sequencemedia/drive` is awake')
+
+/**
+ * Get a JSON file from Google Drive
+ *
+ * @param {string} fileId JSON file identifier
+ * @param {AuthClient} authClient An authorised OAuth2 client
+ * @returns {File}
+ */
+async function getJsonFile (fileId, authClient) {
+  try {
+    const drive = google.drive({
+      version: GOOGLE_DRIVE_VERSION,
+      auth: authClient
+    })
+
+    const {
+      data
+    } = await drive.files.get({
+      fileId,
+      alt: 'media'
+    })
+
+    return data
+  } catch (e) {
+    if (hasErrorCode(e)) error(getErrorCode(e))
+    error(getErrorMessage(e))
+    throw e
+  }
+}
+
+/**
+ * Get a JSON file from Google Drive
+ *
+ * @param {string} fileId JSON file identifier
+ * @param {Record<PropertyKey, string | undefined>} keyFile Authorisation
+ * @param {string[]} scopes Authorisation scopes
+ * @returns {Promise<File>}
+ */
+export default async function getFromDrive (fileId, keyFile, scopes = SCOPES) {
+  return (
+    await getJsonFile(
+      fileId,
+      await authorize(
+        keyFile,
+        scopes
+      )
+    )
+  )
+}

package/src/get-list/index.d.mts

@@ -0,0 +1,8 @@
+/**
+ * Get a list of the JSON files from Google Drive
+ */
+export default function getListFromDrive (
+  driveId: string,
+  keyFile: KeyFileType,
+  scopes?: string[]
+): Promise<FileListType>

package/src/get-list/index.mjs

@@ -0,0 +1,85 @@
+/**
+ * @typedef {import('google-auth-library').OAuth2Client} AuthClient
+ */
+
+import debug from 'debug'
+
+import {
+  google
+} from 'googleapis'
+
+import {
+  GOOGLE_DRIVE_VERSION
+} from '#common/config'
+
+import {
+  hasErrorCode,
+  getErrorCode,
+  getErrorMessage
+} from '#common/error'
+
+import authorize from '#common/authorize'
+
+const SCOPES = [
+  'https://www.googleapis.com/auth/drive'
+]
+
+const log = debug('@sequencemedia/drive/list')
+const error = debug('@sequencemedia/drive/list:error')
+
+log('`@sequencemedia/drive` is awake')
+
+/**
+ * Get a list of the JSON files from Google Drive
+ *
+ * @param {string} driveId Drive identifier
+ * @param {AuthClient} authClient An authorised OAuth2 client
+ * @returns {Promise<{id: string, name: string}[]>}
+ */
+async function getJsonFileList (driveId, authClient) {
+  try {
+    const drive = google.drive({
+      version: GOOGLE_DRIVE_VERSION,
+      auth: authClient
+    })
+
+    const {
+      data: {
+        files = []
+      }
+    } = await drive.files.list({
+      supportsAllDrives: true,
+      corpora: 'drive',
+      includeItemsFromAllDrives: true,
+      fields: 'nextPageToken, files(id, name)',
+      orderBy: 'createdTime desc',
+      driveId
+    })
+
+    return files
+  } catch (e) {
+    if (hasErrorCode(e)) error(getErrorCode(e))
+    error(getErrorMessage(e))
+    throw e
+  }
+}
+
+/**
+ * Get a list of the JSON files from Google Drive
+ *
+ * @param {string} driveId Drive identifier
+ * @param {Record<PropertyKey, string | undefined>} keyFile Authorisation
+ * @param {string[]} scopes Authorisation scopes
+ * @returns {Promise<Array<{id: string, name: string}>>}
+ */
+export default async function getListFromDrive (driveId, keyFile, scopes = SCOPES) {
+  return (
+    await getJsonFileList(
+      driveId,
+      await authorize(
+        keyFile,
+        scopes
+      )
+    )
+  )
+}

package/src/index.d.mts

@@ -0,0 +1,9 @@
+import type { drive_v3 as DriveV3 } from 'googleapis'
+
+declare global {
+  type KeyFileType = Record<PropertyKey, string | undefined>
+
+  type FileType = DriveV3.Schema$File
+
+  type FileListType = Array<{ id: string, name: string }>
+}

package/src/index.mjs

@@ -0,0 +1,4 @@
+export { default as createInDrive } from './create/index.mjs'
+export { default as deleteFromDrive } from './delete/index.mjs'
+export { default as listInDrive } from './list/index.mjs'
+export { default as getFromDrive } from './get/index.mjs'