Add resolved to logger (#15)

* add resolved to logger
* extend the logger in porcelain

Author: ABevier

src/plumbing/install.ts

@@ -23,7 +23,7 @@ export default async function install(pkg: Package, logger?: Logger): Promise<In
   const tarball = useCache().path(stowage)
   const shelf = tea_prefix.join(pkg.project)
 
-  logger?.locking(pkg)
+  logger?.locking?.(pkg)
   const { rid: fd } = await Deno.open(shelf.mkdir('p').string)
   await flock(fd, 'ex')
 
@@ -32,11 +32,11 @@ export default async function install(pkg: Package, logger?: Logger): Promise<In
     if (already_installed) {
       // some other tea instance installed us while we were waiting for the lock
       // or potentially we were already installed and the caller is naughty
-      logger?.installed(already_installed)
+      logger?.installed?.(already_installed)
       return already_installed
     }
 
-    logger?.downloading({pkg})
+    logger?.downloading?.({pkg})
 
     const tmpdir = Path.mktemp({
       dir: tea_prefix.join("local/tmp").join(pkg.project),
@@ -58,13 +58,13 @@ export default async function install(pkg: Package, logger?: Logger): Promise<In
       src: url,
       dst: tarball,
       logger: info => {
-        logger?.downloading({ pkg, ...info })
+        logger?.downloading?.({ pkg, ...info })
         total ??= info.total
       }
     }, blob => {
       n += blob.length
       hasher.update(blob)
-      logger?.installing({ pkg, progress: total ? n / total : total })
+      logger?.installing?.({ pkg, progress: total ? n / total : total })
       return writeAll(untar.stdin, blob)
     })
 
@@ -89,14 +89,14 @@ export default async function install(pkg: Package, logger?: Logger): Promise<In
     const path = tmpdir.mv({ to: shelf.join(`v${pkg.version}`) })
     const install = { pkg, path }
 
-    logger?.installed(install)
+    logger?.installed?.(install)
 
     return install
   } catch (err) {
     tarball.rm()  //FIXME resumable downloads!
     throw err
   } finally {
-    logger?.unlocking(pkg)
+    logger?.unlocking?.(pkg)
     await flock(fd, 'un')
     Deno.close(fd)  // docs aren't clear if we need to do this or not
   }
@@ -111,16 +111,16 @@ async function remote_SHA(url: URL) {
 
 
 export interface Logger {
-  locking(pkg: Package): void
+  locking?(pkg: Package): void
   /// raw http info
-  downloading(info: {pkg: Package, src?: URL, dst?: Path, rcvd?: number, total?: number}): void
+  downloading?(info: {pkg: Package, src?: URL, dst?: Path, rcvd?: number, total?: number}): void
   /// we are simultaneously downloading and untarring the bottle
   /// the install progress here is proper and tied to download progress
   /// progress is a either a fraction between 0 and 1 or the number of bytes that have been untarred
   /// we try to give you the fraction as soon as possible, but you will need to deal with both formats
-  installing(info: {pkg: Package, progress: number | undefined}): void
-  unlocking(pkg: Package): void
-  installed(installation: Installation): void
+  installing?(info: {pkg: Package, progress: number | undefined}): void
+  unlocking?(pkg: Package): void
+  installed?(installation: Installation): void
 }
 
 // deno-lint-ignore no-explicit-any

src/plumbing/resolve.ts

@@ -6,7 +6,7 @@ import TeaError from "../utils/error.ts"
 /// NOTE resolves to bottles
 /// NOTE contract there are no duplicate projects in input
 
-interface RT {
+export interface Resolution {
   /// fully resolved list (includes both installed and pending)
   pkgs: Package[]
 
@@ -22,10 +22,10 @@ interface RT {
 /// that resolve so if we are resolving `node>=12`, node 13 is installed, but
 /// node 19 is the latest we return node 13. if `update` is true we return node
 /// 19 and *you will need to install it*.
-export default async function resolve(reqs: (Package | PackageRequirement)[], {update}: {update: boolean} = {update: false}): Promise<RT> {
+export default async function resolve(reqs: (Package | PackageRequirement)[], {update}: {update: boolean} = {update: false}): Promise<Resolution> {
   const inventory = _internals.useInventory()
   const cellar = _internals.useCellar()
-  const rv: RT = { pkgs: [], installed: [], pending: [] }
+  const rv: Resolution = { pkgs: [], installed: [], pending: [] }
   let installation: Installation | undefined
   for (const req of reqs) {
     if (!update && (installation = await cellar.has(req))) {

src/porcelain/install.test.ts

@@ -1,5 +1,8 @@
 import { useTestConfig } from "../hooks/useTestConfig.ts"
-import { assert } from "deno/testing/asserts.ts"
+import { assert, assertArrayIncludes } from "deno/testing/asserts.ts"
+import { ConsoleLogger } from "../plumbing/install.ts"
+import type { Package } from "../types.ts";
+import type { Resolution } from "../plumbing/resolve.ts";
 import * as semver from "../utils/semver.ts"
 import install from "./install.ts"
 
@@ -27,3 +30,18 @@ Deno.test("porcelain.install.4", async () => {
   useTestConfig()
     await install([{ project: 'tea.xyz/brewkit', constraint: new semver.Range("^0.31") }])
 })
+
+Deno.test("porcelain.install.resolved", async () => {
+  useTestConfig()
+
+  let resolution: Resolution = { pkgs: [] as Package[] } as Resolution
+  const logger = {
+    ...ConsoleLogger(),
+    resolved: (r: Resolution) => resolution = r
+  }
+
+  await install("tea.xyz/brewkit^0.32", logger)
+
+  const resolvedProjects = resolution.pkgs.map((p: Package) => p.project)
+  assertArrayIncludes(resolvedProjects, [ "deno.land", "gnu.org/bash", "tea.xyz", "tea.xyz/brewkit"])
+})

src/porcelain/install.ts

@@ -1,13 +1,17 @@
 import { Installation, PackageSpecification } from "../types.ts"
-import install, { Logger } from "../plumbing/install.ts"
+import install, { Logger as InstallLogger } from "../plumbing/install.ts"
 import usePantry from "../hooks/usePantry.ts"
 import hydrate from "../plumbing/hydrate.ts"
-import resolve from "../plumbing/resolve.ts"
+import resolve, { Resolution } from "../plumbing/resolve.ts"
 import { isArray, isString } from "is-what"
 import { parse } from "../utils/pkg.ts"
 import link from "../plumbing/link.ts"
 import useSync from "../hooks/useSync.ts";
 
+export interface Logger extends InstallLogger {
+  resolved?(resolution: Resolution): void
+}
+
 /// eg. install("python.org~3.10")
 export default async function(pkgs: PackageSpecification[] | string[] | string, logger?: Logger): Promise<Installation[]> {
 
@@ -23,7 +27,10 @@ export default async function(pkgs: PackageSpecification[] | string[] | string,
   //TODO parallelize!
 
   pkgs = (await hydrate(pkgs)).pkgs
-  const { pending, installed } = await resolve(pkgs)
+  const resolution = await resolve(pkgs)
+  logger?.resolved?.(resolution)
+
+  const { pending, installed} = resolution
   for (const pkg of pending) {
     const installation = await install(pkg, logger)
     await link(installation)