Change terminology (Manifest -> Lockfile, Config -> Manifest) (#10)

Author: ghostnaps

examples/package/rbxasset-manifest.toml renamed to examples/package/rbxasset.lock

@@ -9,31 +9,31 @@ flowchart TD;
          --> BeginPublishing
 
     subgraph rbxasset
-        AssetConfig[(rbxasset.toml)]
-        AssetManifest[(rbxasset-manifest.toml)]
+        AssetManifest[(rbxasset.toml)]
+        AssetLockfile[(rbxasset.lock)]
 
         BeginPublishing("publishPackageAsync()")
             --> AssetExists{Asset exists on Creator Store?}
 
         AssetExists -- Yes  --> UpdateVersion(Update asset version with new rbxm)
         AssetExists -- No --> CreateAsset(Create new Package asset)
 
-        AssetManifest -. read assetId .-> UpdateVersion
+        AssetLockfile -. read assetId .-> UpdateVersion
 
         CompareImageHashes{For each image, is there a matching hash?}
         CompareImageHashes -- Yes --> SyncAssetDetails
         CompareImageHashes -- No --> UploadImages
 
-        AssetManifest -. read image hashes .-> CompareImageHashes
+        AssetLockfile -. read image hashes .-> CompareImageHashes
 
-        CreateAsset -. write assetId .-> AssetManifest
+        CreateAsset -. write assetId .-> AssetLockfile
 
         UploadImages(Create Image assets for the icon and previews)
 
-        AssetConfig -. read image paths .-> UploadImages
+        AssetManifest -. read image paths .-> UploadImages
 
         SyncAssetDetails(Sync asset name, description, icon, and distribution status to Creator Store)
-        AssetConfig -. read name, description, distribution status .-> SyncAssetDetails
+        AssetManifest -. read name, description, distribution status .-> SyncAssetDetails
 
         UpdateVersion
             --> CreateAssetVersionAsync("AssetService:CreateAssetVersionAsync()")
@@ -44,7 +44,7 @@ flowchart TD;
             --> CompareImageHashes
 
         UploadImages --> SyncAssetDetails
-        UploadImages -. store image hash and id .->  AssetManifest
+        UploadImages -. store image hash and id .->  AssetLockfile
     end
 
     SyncAssetDetails

examples/plugin/rbxasset-manifest.toml renamed to examples/plugin/rbxasset.lock

@@ -1,4 +1,4 @@
 return {
-	ASSET_CONFIG_FILENAME = "rbxasset.toml",
-	ASSET_MANIFEST_FILENAME = "rbxasset-manifest.toml",
+	ASSET_MANIFEST_FILENAME = "rbxasset.toml",
+	ASSET_LOCKFILE_FILENAME = "rbxasset.lock",
 }

examples/workspace/rbxasset-manifest.toml renamed to examples/workspace/rbxasset.lock

@@ -1,6 +1,5 @@
 local types = require("@self/types")
 
-export type Config = types.Config
 export type Manifest = types.Manifest
 
 return {

specs/publishPackageAsync.md

@@ -0,0 +1,35 @@
+local fs = require("@lune/fs")
+local serde = require("@lune/serde")
+
+local constants = require("@root/constants")
+local join = require("@root/lib/join")
+local logging = require("@root/logging")
+local types = require("@root/types")
+
+type Lockfile = types.Lockfile
+
+local function getOrCreateAssetLockfile(packagePath: string): Lockfile
+	local lockfilePath = `{packagePath}/{constants.ASSET_LOCKFILE_FILENAME}`
+
+	-- It's expected that the lockfile won't exist in certain situations, like
+	-- on the first upload of the asset. So we just catch any error here
+	local content: string
+	local success = pcall(function()
+		content = fs.readFile(lockfilePath)
+	end)
+
+	local parsedLockfile = if success then serde.decode("toml", content) else nil
+	local lockfile: Lockfile = join({
+		assets = {},
+		images = {},
+	}, parsedLockfile)
+
+	local isLockfileValid, message = types.validateLockfile(lockfile)
+	assert(isLockfileValid, `failed to parse asset lockfile at {lockfilePath}: {message}`)
+
+	logging.debug(`loaded asset lockfile {lockfile}`)
+
+	return lockfile
+end
+
+return getOrCreateAssetLockfile

src/constants.luau

@@ -0,0 +1,18 @@
+local frktest = require("@pkg/frktest/src/frktest")
+local test = frktest.test
+local check = frktest.assert.check
+
+local getOrCreateAssetLockfile = require("./getOrCreateAssetLockfile")
+
+test.case("reads an asset lockfile from disk", function()
+	local lockfile = getOrCreateAssetLockfile("examples/package")
+	check.equal(lockfile.assets["package"].assetId, "70942996502762")
+end)
+
+test.case("creates a blank asset lockfile when not found on disk", function()
+	local lockfile = getOrCreateAssetLockfile("/nowhere")
+	check.table.equal(lockfile, {
+		assets = {},
+		images = {},
+	})
+end)