@leverege/build-tools 2.93.0-beta.5 → 2.93.0-beta.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@leverege/build-tools",
-  "version": "2.93.0-beta.5",
+  "version": "2.93.0-beta.8",
   "description": "A collection of build / support tools for Leverege developers",
   "main": "index.js",
   "repository": {
@@ -50,12 +50,13 @@
     "npm-link": "src/npm-link.sh",
     "npm-unlink": "src/npm-unlink.sh",
     "overwhelm": "src/overwhelm.mjs",
-    "package-artifact": "src/package-artifact/command.mjs",
     "pkgck": "src/pkgck.sh",
     "pkglint": "src/pkglint.sh",
     "prepack": "src/prepack.mjs",
     "prune-git": "src/prune-git.sh",
+    "pull-artifact": "src/artifacts/pull-artifact.mjs",
     "pull-git": "src/pull-git.sh",
+    "push-artifact": "src/artifacts/push-artifact.mjs",
     "push-my-chart": "src/push-my-chart.mjs",
     "refresh-npm-token": "src/refresh-npm-token.mjs",
     "refresh-py-idx": "src/refresh-py-idx.sh",

package/src/artifacts/ArtifactPuller.mjs

@@ -0,0 +1,21 @@
+import crypto from 'crypto'
+import fs from 'fs'
+
+class ArtifactPusher {
+  constructor( artifact ) {
+    this.artifact = artifact
+  }
+
+  async pull() {
+    throw new Error( 'Not implemented' )
+  }
+}
+
+class GenericArtifactPusher extends ArtifactPusher {
+
+  async pull() {
+    throw new Error( 'Not implemented' )
+  }
+}
+
+export { ArtifactPusher, GenericArtifactPusher }

package/src/{package-artifact/Packager.mjs → artifacts/ArtifactPusher.mjs}

@@ -1,7 +1,7 @@
 import crypto from 'crypto'
 import fs from 'fs'
 
-class ArtifactPackager {
+class ArtifactPusher {
   constructor( artifact ) {
     this.artifact = artifact
   }
@@ -12,6 +12,7 @@ class ArtifactPackager {
       hash.update( fs.readFileSync( this.artifact.source_path ) )
       return hash.digest( 'base64url' )
     } catch ( error ) {
+      console.error( error )
       throw new Error( `Failed to calculate hash for artifact ${this.artifact.name}: ${error.message}` )
     }
   }
@@ -20,27 +21,24 @@ class ArtifactPackager {
     throw new Error( 'Not implemented' )
   }
 
-  async build() {
+  async push() {
     throw new Error( 'Not implemented' )
   }
+}
 
-  async publish() {
-    throw new Error( 'Not implemented' )
-  }
+class GenericArtifactPusher extends ArtifactPusher {
 
-  async package() {
-    if ( await this.exists() ) {
-      console.log( 'Artifact already exists in the registry' )
+  async exists() {
+    const isDirectory = fs.statSync( this.artifact.source_path ).isDirectory()
+    
+    // If source path is a directory, check whether the destination path alreadu exists in the registry
+    if ( isDirectory ) {
+      // For the time being, return false, and let gcloud skip existing files in upload-time.
+      // It's pretty slow, might be worth to break down the directory into individual artifacts
+      // and manage each one with its own pusher.
       return false
     }
-    await this.build()
-    return this.publish()
-  }
-}
-
-class GenericArtifactPackager extends ArtifactPackager {
 
-  async exists() {
     // Check if artifact already exists in the registry
     console.log( 'Checking if artifact already exists in the registry...' )
         
@@ -84,22 +82,37 @@ class GenericArtifactPackager extends ArtifactPackager {
       throw error
     }
   }
-
-  async build() {
-    return true
-  }
     
-  async publish() {
+  async push() {
     console.log( 'Publishing artifact to registry...' )
-        
-    const command = `gcloud artifacts generic upload \
-        --project=${this.artifact.gcp_project_id} \
-        --location=${this.artifact.gcp_location} \
-        --repository=${this.artifact.gcp_artifact_registry_repository_name} \
-        --package=${this.artifact.gcp_artifact_registry_package_name} \
-        --version=${this.artifact.gcp_artifact_registry_package_version} \
-        --source=${this.artifact.source_path} \
-        --destination-path=${this.artifact.destination_path}`
+
+    if ( await this.exists() ) {
+      console.log( 'Artifact already exists in the registry' )
+      return false
+    }
+
+    console.log( 'Uploading artifact to registry...' )
+   
+    let command = ''
+
+    command = `gcloud artifacts generic upload \
+      --project=${this.artifact.gcp_project_id} \
+      --location=${this.artifact.gcp_location} \
+      --repository=${this.artifact.gcp_artifact_registry_repository_name} \
+      --package=${this.artifact.gcp_artifact_registry_package_name} \
+      --version=${this.artifact.gcp_artifact_registry_package_version}`
+
+    const isDirectory = fs.statSync( this.artifact.source_path ).isDirectory()
+    if ( isDirectory ) {
+      command += ` --source-directory=${this.artifact.source_path}`
+      command += ' --skip-existing'
+    } else {
+      command += ` --source=${this.artifact.source_path}`
+    }
+
+    if ( this.artifact.destination_path ) {
+      command += ` --destination-path=${this.artifact.destination_path}`
+    }
     
     // console.log( 'Command:', command )
         
@@ -115,4 +128,4 @@ class GenericArtifactPackager extends ArtifactPackager {
   }
 }
 
-export { ArtifactPackager, GenericArtifactPackager }
+export { ArtifactPusher, GenericArtifactPusher }

package/src/{package-artifact → artifacts}/Structs.mjs

@@ -1,11 +1,13 @@
 import { assign, object, string, array, optional, enums, union } from 'superstruct'
 
-const ArtifactTypeEnum = enums( [ 'generic' ] )
+const ArtifactTypeEnum = {
+  GENERIC : 'generic',
+}
 
 // Superstruct schema for individual artifact configuration
-const PartialArtifactEntrySchema = object( {
+const PartialArtifactSchema = object( {
   name : string(),
-  type : optional( ArtifactTypeEnum ),
+  type : optional( enums( Object.values( ArtifactTypeEnum ) ) ),
   gcp_project_id : optional( string() ),
   gcp_location : optional( string() ),
   gcp_artifact_registry_repository_name : optional( string() ),
@@ -13,9 +15,9 @@ const PartialArtifactEntrySchema = object( {
   gcp_artifact_registry_package_version : optional( string() )
 } )
 
-const ArtifactEntrySchema = assign( PartialArtifactEntrySchema, object( {
+const ArtifactSchema = assign( PartialArtifactSchema, object( {
   name : string(),
-  type : ArtifactTypeEnum,
+  type : enums( Object.values( ArtifactTypeEnum ) ),
   gcp_project_id : string(),
   gcp_location : string(),
   gcp_artifact_registry_repository_name : string(),
@@ -23,15 +25,15 @@ const ArtifactEntrySchema = assign( PartialArtifactEntrySchema, object( {
   gcp_artifact_registry_package_version : string()
 } ) )
 
-const PartialGenericArtifactEntrySchema = assign( PartialArtifactEntrySchema, object( {
-  type : enums( [ 'generic' ] ),
+const PartialGenericArtifactSchema = assign( PartialArtifactSchema, object( {
+  type : enums( [ ArtifactTypeEnum.GENERIC ] ),
   source_path : string(),
   destination_path : string()
 } ) )
 
-const GenericArtifactEntrySchema = assign( ArtifactEntrySchema, object( {
+const GenericArtifactSchema = assign( ArtifactSchema, object( {
   source_path : string(),
-  destination_path : string()
+  destination_path : optional( string() )
 } ) )
 
 // Superstruct schema for defaults configuration
@@ -44,17 +46,18 @@ const DefaultsSchema = object( {
 } )
 
 // Superstruct schema for the complete artifacts configuration with defaults
-const ArtifactEntriesSchema = object( {
-  defaults : DefaultsSchema,
-  artifacts : array( union( [ PartialArtifactEntrySchema, PartialGenericArtifactEntrySchema ] ) )
+const ArtifactsSchema = object( {
+  defaults : optional( DefaultsSchema ),
+  artifacts : array( union( [ PartialArtifactSchema, PartialGenericArtifactSchema ] ) )
 } )
 
-const FlattenedArtifactEntriesSchema = array( assign( union( [ ArtifactEntrySchema, GenericArtifactEntrySchema ] ) ) )
+const FlattenedArtifactsSchema = array( assign( union( [ ArtifactSchema, GenericArtifactSchema ] ) ) )
 
 export {
-  ArtifactEntriesSchema,
-  FlattenedArtifactEntriesSchema,
-  ArtifactEntrySchema,
+  ArtifactTypeEnum,
+  ArtifactsSchema,
+  FlattenedArtifactsSchema,
+  ArtifactSchema,
   DefaultsSchema,
-  GenericArtifactEntrySchema,
+  GenericArtifactSchema,
 }

package/src/{package-artifact → artifacts}/Utils.mjs

@@ -2,18 +2,18 @@ import { validate } from 'superstruct'
 
 import { parseYamlFile, warning } from '../Utils.mjs'
 
-import { ArtifactEntriesSchema, GenericArtifactEntrySchema } from './Structs.mjs'
+import { ArtifactTypeEnum, ArtifactsSchema, GenericArtifactSchema } from './Structs.mjs'
 
-const getArtifactEntriesSchema = async ( artifactsConfigPath = './artifacts.yml' ) => {
-  const artifactsConfig = await parseYamlFile( artifactsConfigPath )
-  const [ error, result ] = validate( artifactsConfig, ArtifactEntriesSchema )
+const getArtifactsSchema = async ( artifactsFilePath = './artifacts.yml' ) => {
+  const artifactsConfig = await parseYamlFile( artifactsFilePath )
+  const [ error, result ] = validate( artifactsConfig, ArtifactsSchema )
   if ( error ) {
     throw new Error( `Invalid artifacts.yml file: ${error.message}` )
   }
   return result
 }
 
-const flattenArtifactEntriesSchema = ( artifactsSchema ) => {
+const flattenArtifactsSchema = ( artifactsSchema ) => {
   return artifactsSchema.artifacts.reduce( ( flattenedArtifacts, artifact ) => {
     const mergedArtifact = {
       ...artifactsSchema.defaults,
@@ -22,8 +22,8 @@ const flattenArtifactEntriesSchema = ( artifactsSchema ) => {
     
     let schema
     switch ( mergedArtifact.type ) {
-      case 'generic':
-        schema = GenericArtifactEntrySchema
+      case ArtifactTypeEnum.GENERIC:
+        schema = GenericArtifactSchema
         break
       default:
         warning( `Unsupported artifact type "${mergedArtifact.type}"` )
@@ -46,4 +46,4 @@ const flattenArtifactEntriesSchema = ( artifactsSchema ) => {
   }, [] )
 }
 
-export { getArtifactEntriesSchema, flattenArtifactEntriesSchema }
+export { getArtifactsSchema, flattenArtifactsSchema }

package/src/artifacts/pull-artifact.mjs

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+
+async function main() {
+  return null
+}
+
+main()

package/src/{package-artifact/command.mjs → artifacts/push-artifact.mjs}

@@ -2,8 +2,9 @@
 
 import { warning } from '../Utils.mjs'
 
-import { getArtifactEntriesSchema, flattenArtifactEntriesSchema } from './Utils.mjs'
-import { GenericArtifactPackager } from './Packager.mjs'
+import { getArtifactsSchema, flattenArtifactsSchema } from './Utils.mjs'
+import { ArtifactTypeEnum } from './Structs.mjs'
+import { GenericArtifactPusher } from './ArtifactPusher.mjs'
 
 async function main() {
 
@@ -13,8 +14,8 @@ async function main() {
   const artifactPackageVersion = process.argv[4]
 
   if ( artifactsYmlPath ) {
-    const artifactsSchema = await getArtifactEntriesSchema( artifactsYmlPath )
-    const flattenedArtifactsSchema = flattenArtifactEntriesSchema( artifactsSchema )
+    const artifactsSchema = await getArtifactsSchema( artifactsYmlPath )
+    const flattenedArtifactsSchema = flattenArtifactsSchema( artifactsSchema )
     
     // Open for unexpected matches if we end up re-using the same package name and version for
     // multiple artifacts spread across multiple repositories and/or projects.
@@ -23,14 +24,16 @@ async function main() {
       artifact.gcp_artifact_registry_package_version === artifactPackageVersion )
     
     if ( filteredArtifactSchemas.length === 0 ) {
-      console.error( `No artifact entries found for ${artifactPackageName} version ${artifactPackageVersion} in ${artifactsYmlPath}` )
+      console.error( `No artifacts found for ${artifactPackageName} version ${artifactPackageVersion} in ${artifactsYmlPath}` )
       process.exit( 1 )
     }
+
+    // TODO: Use concurrency to package artifacts and provide summary of results.
     for ( const artifactSchema of filteredArtifactSchemas ) {
       let packager
       switch ( artifactSchema.type ) {
-        case 'generic':
-          packager = new GenericArtifactPackager( artifactSchema )
+        case ArtifactTypeEnum.GENERIC:
+          packager = new GenericArtifactPusher( artifactSchema )
           break
         default:
           warning( `Unsupported artifact type "${artifactSchema.type}"` )