@genoacms/adapter-gcp 0.5.2-fix.2 → 0.5.2-fix.6

package/dist/services/deployment/deploy.d.ts

@@ -1 +1,2 @@
-export default function (): Promise<void>;
+declare function deploy(): Promise<void>;
+export default deploy;

package/dist/services/deployment/deploy.js

@@ -1,8 +1,8 @@
 import config from '../../config.js';
-import { getBucket } from '../storage/storage.js';
 import { readdir, lstat } from 'node:fs/promises';
 import { createReadStream, createWriteStream } from 'node:fs';
-import { join } from 'node:path';
+import { join, resolve, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
 import { CloudFunctionsServiceClient } from '@google-cloud/functions';
 import archiver from 'archiver';
 const functionsClient = new CloudFunctionsServiceClient({
@@ -10,29 +10,37 @@ const functionsClient = new CloudFunctionsServiceClient({
 });
 const projectId = config.deployment.projectId;
 const region = config.deployment.region;
+const { uploadObject, getSignedURL } = await config.storage.adapter;
+function locateFunctionEntryScript() {
+    const currentDir = dirname(fileURLToPath(import.meta.url));
+    const indexPath = resolve(currentDir, './snippets/index.js');
+    return indexPath;
+}
+async function uploadFile(bucketName, filePath, destination) {
+    const reference = { bucket: bucketName, name: destination };
+    await uploadObject(reference, createReadStream(filePath));
+    return await getSignedURL(reference, new Date(Date.now() + 1000 * 60 * 60 * 12));
+}
+async function uploadFileOrDirectory(bucketName, path, prefix = '') {
+    const isDirectory = (await lstat(path)).isDirectory();
+    if (isDirectory) {
+        await uploadDirectory(bucketName, path, prefix);
+    }
+    else {
+        await uploadFile(bucketName, path, prefix);
+    }
+}
 async function uploadDirectory(bucketName, directoryPath, prefix = '') {
-    const bucket = getBucket(bucketName);
     const files = await readdir(directoryPath);
+    const promises = [];
     for (const file of files) {
         const filePath = join(directoryPath, file);
         const destination = join(prefix, file);
-        const isFileDirectory = (await lstat(filePath)).isDirectory();
-        if (isFileDirectory) {
-            await uploadDirectory(bucketName, filePath, destination);
-        }
-        else {
-            const fileStream = createReadStream(filePath);
-            const gcsFile = bucket.file(destination);
-            await new Promise((resolve, reject) => {
-                fileStream
-                    .pipe(gcsFile.createWriteStream())
-                    .on('error', reject)
-                    .on('finish', resolve);
-            });
-        }
+        promises.push(uploadFileOrDirectory(bucketName, filePath, destination));
     }
+    await Promise.all(promises);
 }
-async function zipDirectory(source, out) {
+async function createZip(source, injectPaths, ignorePaths, out) {
     await new Promise((resolve, reject) => {
         const output = createWriteStream(out);
         const archive = archiver('zip', { zlib: { level: 9 } });
@@ -43,36 +51,83 @@ async function zipDirectory(source, out) {
             reject(err);
         });
         archive.pipe(output);
-        archive.directory(source, false);
+        archive.glob(source, { ignore: ignorePaths });
+        for (const path of injectPaths) {
+            archive.append(path, { name: path });
+        }
         archive.finalize();
     });
 }
+async function uploadSource(sourceArchivePath) {
+    const location = functionsClient.locationPath(projectId, region);
+    const [urlResponse] = await functionsClient.generateUploadUrl({ parent: location });
+    const uploadUrl = urlResponse.uploadUrl;
+    if (!uploadUrl)
+        throw new Error('Upload URL not found');
+    const sourceArchiveStream = createReadStream(sourceArchivePath);
+    await fetch(uploadUrl, {
+        method: 'PUT',
+        // @ts-expect-error: invalid typings
+        body: sourceArchiveStream,
+        duplex: 'half',
+        headers: {
+            'Content-Type': 'application/zip'
+        }
+    });
+    return uploadUrl;
+}
 async function deployFunction(functionName, source) {
     const location = functionsClient.locationPath(projectId, region);
     const name = functionsClient.cloudFunctionPath(projectId, region, functionName);
-    const [response] = await functionsClient.createFunction({
+    let isFunctionExisting;
+    try {
+        await functionsClient.getFunction({ name });
+        isFunctionExisting = true;
+    }
+    catch (error) {
+        isFunctionExisting = false;
+    }
+    const operationParams = {
         location,
         function: {
             name,
             sourceUploadUrl: source,
-            entryPoint: 'handler',
+            entryPoint: 'svelteKitApp',
             runtime: 'nodejs20',
             httpsTrigger: {},
             environmentVariables: {
                 NODE_ENV: 'production'
             }
         }
-    }, {});
-    console.log(response);
+    };
+    let response;
+    if (isFunctionExisting) {
+        [response] = await functionsClient.updateFunction(operationParams, {});
+    }
+    else {
+        [response] = await functionsClient.createFunction(operationParams, {});
+    }
+    console.log(response, source);
 }
-export default async function () {
+async function deploy() {
     const bucketName = config.storage.defaultBucket;
-    const assetsPath = '.genoacms/deployment/static';
-    const buildArchiveSrc = '.build.zip';
-    const buildArchiveDest = '.genoacms/deployment/build.zip';
-    const buildArchiveRef = `gs://${bucketName}/${buildArchiveDest}`;
-    await zipDirectory('./build', buildArchiveSrc);
-    await uploadDirectory(bucketName, './static', assetsPath);
-    await uploadDirectory(bucketName, buildArchiveSrc, buildArchiveDest);
-    await deployFunction('genoacms', buildArchiveRef);
+    const buildDirectoryPath = './*';
+    const buildArchivePath = '.build.zip';
+    const assetsDirectoryPath = './static';
+    const assetsDestPath = '.genoacms/deployment/static';
+    const ignoreArchivePaths = [
+        'node_modules',
+        '.git',
+        '.github',
+        '.gitignore',
+        'build'
+    ];
+    const injectArchivePaths = [
+        locateFunctionEntryScript()
+    ];
+    await createZip(buildDirectoryPath, injectArchivePaths, ignoreArchivePaths, buildArchivePath);
+    const uploadUrl = await uploadSource(buildArchivePath);
+    await uploadDirectory(bucketName, assetsDirectoryPath, assetsDestPath);
+    await deployFunction('genoacms', uploadUrl);
 }
+export default deploy;

package/dist/services/storage/index.js

@@ -11,11 +11,9 @@ const getPublicURL = async ({ bucket, name }) => {
     const file = bucketInstance.file(name);
     return file.publicUrl();
 };
-const getSignedURL = async ({ bucket, name }) => {
+const getSignedURL = async ({ bucket, name }, expires) => {
     const bucketInstance = getBucket(bucket);
     const file = bucketInstance.file(name);
-    const expires = new Date();
-    expires.setTime(expires.getTime() + 60 * 60 * 1_000);
     const [url] = await file.getSignedUrl({
         action: 'read',
         expires

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@genoacms/adapter-gcp",
-  "version": "0.5.2-fix.2",
+  "version": "0.5.2-fix.6",
   "description": "Implementation of abstraction layer of GenoaCMS for GCP",
   "repository": {
     "type": "git",
@@ -20,6 +20,7 @@
     "@genoacms/cloudabstraction": "^0.5.2",
     "@google-cloud/firestore": "^7.1.0",
     "@google-cloud/functions": "^3.2.0",
+    "@google-cloud/functions-framework": "^3.3.0",
     "@google-cloud/resource-manager": "^5.1.0",
     "@google-cloud/storage": "^7.7.0",
     "archiver": "^7.0.0"

package/src/services/deployment/deploy.ts

@@ -1,8 +1,8 @@
 import config from '../../config.js'
-import { getBucket } from '../storage/storage.js'
 import { readdir, lstat } from 'node:fs/promises'
 import { createReadStream, createWriteStream } from 'node:fs'
-import { join } from 'node:path'
+import { join, resolve, dirname } from 'node:path'
+import { fileURLToPath } from 'node:url'
 import { CloudFunctionsServiceClient } from '@google-cloud/functions'
 import archiver from 'archiver'
 
@@ -11,33 +11,41 @@ const functionsClient = new CloudFunctionsServiceClient({
 })
 const projectId = config.deployment.projectId
 const region = config.deployment.region
+const { uploadObject, getSignedURL } = await config.storage.adapter
+
+function locateFunctionEntryScript (): string {
+  const currentDir = dirname(fileURLToPath(import.meta.url))
+  const indexPath = resolve(currentDir, './snippets/index.js')
+  return indexPath
+}
+async function uploadFile (bucketName: string, filePath: string, destination: string): Promise<void> {
+  const reference = { bucket: bucketName, name: destination }
+  await uploadObject(reference, createReadStream(filePath))
+  return await getSignedURL(reference, new Date(Date.now() + 1000 * 60 * 60 * 12))
+}
+
+async function uploadFileOrDirectory (bucketName: string, path: string, prefix = ''): Promise<void> {
+  const isDirectory = (await lstat(path)).isDirectory()
+  if (isDirectory) {
+    await uploadDirectory(bucketName, path, prefix)
+  } else {
+    await uploadFile(bucketName, path, prefix)
+  }
+}
 
 async function uploadDirectory (bucketName: string, directoryPath: string, prefix = ''): Promise<void> {
-  const bucket = getBucket(bucketName)
   const files = await readdir(directoryPath)
+  const promises = []
 
   for (const file of files) {
     const filePath = join(directoryPath, file)
     const destination = join(prefix, file)
-
-    const isFileDirectory = (await lstat(filePath)).isDirectory()
-    if (isFileDirectory) {
-      await uploadDirectory(bucketName, filePath, destination)
-    } else {
-      const fileStream = createReadStream(filePath)
-      const gcsFile = bucket.file(destination)
-
-      await new Promise((resolve, reject) => {
-        fileStream
-          .pipe(gcsFile.createWriteStream())
-          .on('error', reject)
-          .on('finish', resolve)
-      })
-    }
+    promises.push(uploadFileOrDirectory(bucketName, filePath, destination))
   }
+  await Promise.all(promises)
 }
 
-async function zipDirectory (source: string, out: string): Promise<void> {
+async function createZip (source: string, injectPaths: string[], ignorePaths: string[], out: string): Promise<void> {
   await new Promise<void>((resolve, reject) => {
     const output = createWriteStream(out)
     const archive = archiver('zip', { zlib: { level: 9 } })
@@ -51,38 +59,84 @@ async function zipDirectory (source: string, out: string): Promise<void> {
     })
 
     archive.pipe(output)
-    archive.directory(source, false)
+    archive.glob(source, { ignore: ignorePaths })
+    for (const path of injectPaths) {
+      archive.append(path, { name: path })
+    }
     archive.finalize()
   })
 }
 
+async function uploadSource (sourceArchivePath: string): Promise<string> {
+  const location = functionsClient.locationPath(projectId, region)
+  const [urlResponse] = await functionsClient.generateUploadUrl({ parent: location })
+  const uploadUrl = urlResponse.uploadUrl
+  if (!uploadUrl) throw new Error('Upload URL not found')
+  const sourceArchiveStream = createReadStream(sourceArchivePath)
+  await fetch(uploadUrl, {
+    method: 'PUT',
+    // @ts-expect-error: invalid typings
+    body: sourceArchiveStream,
+    duplex: 'half',
+    headers: {
+      'Content-Type': 'application/zip'
+    }
+  })
+  return uploadUrl
+}
+
 async function deployFunction (functionName: string, source: string): Promise<void> {
   const location = functionsClient.locationPath(projectId, region)
   const name = functionsClient.cloudFunctionPath(projectId, region, functionName)
-  const [response] = await functionsClient.createFunction({
+  let isFunctionExisting: boolean
+  try {
+    await functionsClient.getFunction({ name })
+    isFunctionExisting = true
+  } catch (error) {
+    isFunctionExisting = false
+  }
+  const operationParams = {
     location,
     function: {
       name,
       sourceUploadUrl: source,
-      entryPoint: 'handler',
+      entryPoint: 'svelteKitApp',
       runtime: 'nodejs20',
       httpsTrigger: {},
       environmentVariables: {
         NODE_ENV: 'production'
       }
     }
-  }, {})
-  console.log(response)
+  }
+  let response
+  if (isFunctionExisting) {
+    [response] = await functionsClient.updateFunction(operationParams, {})
+  } else {
+    [response] = await functionsClient.createFunction(operationParams, {})
+  }
+  console.log(response, source)
 }
 
-export default async function (): Promise<void> {
+async function deploy (): Promise<void> {
   const bucketName = config.storage.defaultBucket
-  const assetsPath = '.genoacms/deployment/static'
-  const buildArchiveSrc = '.build.zip'
-  const buildArchiveDest = '.genoacms/deployment/build.zip'
-  const buildArchiveRef = `gs://${bucketName}/${buildArchiveDest}`
-  await zipDirectory('./build', buildArchiveSrc)
-  await uploadDirectory(bucketName, './static', assetsPath)
-  await uploadDirectory(bucketName, buildArchiveSrc, buildArchiveDest)
-  await deployFunction('genoacms', buildArchiveRef)
+  const buildDirectoryPath = './*'
+  const buildArchivePath = '.build.zip'
+  const assetsDirectoryPath = './static'
+  const assetsDestPath = '.genoacms/deployment/static'
+  const ignoreArchivePaths = [
+    'node_modules',
+    '.git',
+    '.github',
+    '.gitignore',
+    'build'
+  ]
+  const injectArchivePaths = [
+    locateFunctionEntryScript()
+  ]
+  await createZip(buildDirectoryPath, injectArchivePaths, ignoreArchivePaths, buildArchivePath)
+  const uploadUrl = await uploadSource(buildArchivePath)
+  await uploadDirectory(bucketName, assetsDirectoryPath, assetsDestPath)
+  await deployFunction('genoacms', uploadUrl)
 }
+
+export default deploy

package/src/services/deployment/{cloudFunction.js → snippets/index.js}

@@ -1,7 +1,7 @@
 import { HttpFunction } from '@google-cloud/functions-framework'
-import app from './build'
+import { handler } from './build/handler.js'
 
-const svelteKitApp = HttpFunction(app.handler)
+const svelteKitApp = new HttpFunction(handler)
 
 export {
   svelteKitApp

package/src/services/storage/index.ts

@@ -20,11 +20,9 @@ const getPublicURL: Adapter.getPublicURL = async ({ bucket, name }) => {
   return file.publicUrl()
 }
 
-const getSignedURL: Adapter.getSignedURL = async ({ bucket, name }) => {
+const getSignedURL: Adapter.getSignedURL = async ({ bucket, name }, expires) => {
   const bucketInstance = getBucket(bucket)
   const file = bucketInstance.file(name)
-  const expires = new Date()
-  expires.setTime(expires.getTime() + 60 * 60 * 1_000)
   const [url] = await file.getSignedUrl({
     action: 'read',
     expires