@foss.global/codefeed 5.5.0 → 5.7.0

package/ts/classes.giteasourceinventory.ts

@@ -25,6 +25,7 @@ type IInventory = plugins.fossInterfaces.data.IForgeSourceInventory;
 type TAccessMode = plugins.fossInterfaces.data.TForgeSourceAccessMode;
 type TTeamVisibility = plugins.fossInterfaces.data.TForgeSourceTeamVisibility;
 type ITeamRecord = plugins.fossInterfaces.data.IForgeSourceTeamRecord;
+type IOrganizationProfile = plugins.fossInterfaces.data.IForgeSourceOrganizationProfile;
 type IUserSshKey = plugins.fossInterfaces.data.IForgeSourceUserSshKey;
 type ICollaborator = plugins.fossInterfaces.data.IForgeSourceCollaborator;
 type IDeployKey = plugins.fossInterfaces.data.IForgeSourceDeployKey;
@@ -917,6 +918,13 @@ export class GiteaSourceInventory {
     const path = `/orgs/${encodeURIComponent(nameArg)}`;
     const organization = validation.record((await this.#get(path, { signal: signalArg })).body);
     if (segment(organization.name) !== nameArg) throw new validation.ForgeInventoryError('owner-identity-changed');
+    // Verbatim, '' when unset; the website is not validated, since a value Gitea's web form stored may not be a URL.
+    const profile: IOrganizationProfile = {
+      fullName: text(organization.full_name),
+      description: text(organization.description),
+      website: text(organization.website),
+      location: text(organization.location),
+    };
     const labels = await this.#list(`${path}/labels`, { signal: signalArg });
     const teams = await this.#list(`${path}/teams`, { signal: signalArg });
     const memberships: TMeasure[] = [];
@@ -954,6 +962,7 @@ export class GiteaSourceInventory {
         : null,
       // Recorded by every owner unit; the composed inventory keeps them exactly when discovery selects collaboration.
       labelRecords: labels.failure === null ? labels.items.map(labelRecord).sort(byId) : null,
+      profile,
     };
   }
 
@@ -970,6 +979,8 @@ export class GiteaSourceInventory {
       restricted: requiredBoolean(user.restricted),
       prohibitLogin: requiredBoolean(user.prohibit_login),
     };
+    // Verbatim, '' when unset.
+    const fullName = text(user.full_name);
     // As an administrator this lists every key of the user.
     const sshKeys = await this.#list(`${path}/keys`, { signal: signalArg });
     const keyRecords = sshKeys.items.map(userSshKey).sort((aArg, bArg) => compareDecimal(aArg.id, bArg.id));
@@ -983,7 +994,10 @@ export class GiteaSourceInventory {
       sshKeys: listingMeasure(sshKeys),
       gpgKeys: await this.#count(`${path}/gpg_keys`, { signal: signalArg }),
       userRecord: sshKeys.failure === null
-        ? { id: base.id, login: nameArg, active: flags.active, admin: flags.admin, restricted: flags.restricted, prohibitLogin: flags.prohibitLogin, visibility: base.visibility, sshKeys: keyRecords }
+        ? {
+          id: base.id, login: nameArg, active: flags.active, admin: flags.admin, restricted: flags.restricted, prohibitLogin: flags.prohibitLogin,
+          visibility: base.visibility, sshKeys: keyRecords, fullName,
+        }
         : null,
     };
   }
@@ -1876,9 +1890,17 @@ export const composeGiteaSourceInventory = (
   }
 
   const collaborationSelected = discoveryArg.collaboration === true;
-  /** An organization keeps its label records exactly when discovery selects collaboration. */
+  /**
+   * An organization keeps its label records exactly when discovery selects
+   * collaboration. An organization profile or a user's full name a stored
+   * result lacks (a reader before 5.7.0) stays absent and is a reason.
+   */
   const ownerOfRun = (ownerArg: TOwner): TOwner => {
-    if (ownerArg.kind !== 'organization') return ownerArg;
+    if (ownerArg.kind === 'user') {
+      if (ownerArg.userRecord && ownerArg.userRecord.fullName === undefined) addReason('user.userRecord.fullName: Measured by a generator that predates user full names.');
+      return ownerArg;
+    }
+    if (ownerArg.profile === undefined) addReason('organization.profile: Measured by a generator that predates organization profiles.');
     const { labelRecords, ...organization } = ownerArg;
     if (!collaborationSelected) return organization;
     if (labelRecords !== undefined) return { ...organization, labelRecords };

package/ts/forgeinventory.transport.ts

@@ -72,14 +72,32 @@ export interface INodeResponse extends IForgeTransportResponse {
   sent: Promise<void>;
 }
 
+/**
+ * A lookup that answers every name with `addressArg`, an IP address, in the
+ * form the caller asks for (one address, or a list with `all`).
+ */
+const fixedLookup = (addressArg: string): plugins.net.LookupFunction => {
+  const family = plugins.net.isIP(addressArg);
+  return (_hostnameArg, optionsArg, callbackArg) => {
+    if (optionsArg.all) callbackArg(null, [{ address: addressArg, family }]);
+    else callbackArg(null, addressArg, family);
+  };
+};
+
 /**
  * Idle keep-alive agents that unreference their pooled sockets, so pooled
- * connections never keep the process alive.
+ * connections never keep the process alive. With `connectAddressArg`, an IP
+ * address, every connection goes to that address on the URL's port instead
+ * of the one DNS gives for the URL's host; the Host header, the TLS server
+ * name and the certificate check stay the URL's host.
  */
-export const createNodeAgents = (caCertificatesArg?: string[], allowHttpArg = false): INodeRequestAgents => ({
-  https: new plugins.https.Agent({ ...(caCertificatesArg ? { ca: caCertificatesArg } : {}), keepAlive: true, timeout: idleSocketTimeoutMs }),
-  ...(allowHttpArg ? { http: new plugins.http.Agent({ keepAlive: true, timeout: idleSocketTimeoutMs }) } : {}),
-});
+export const createNodeAgents = (caCertificatesArg?: string[], allowHttpArg = false, connectAddressArg?: string): INodeRequestAgents => {
+  const lookup = connectAddressArg === undefined ? {} : { lookup: fixedLookup(connectAddressArg) };
+  return {
+    https: new plugins.https.Agent({ ...(caCertificatesArg ? { ca: caCertificatesArg } : {}), ...lookup, keepAlive: true, timeout: idleSocketTimeoutMs }),
+    ...(allowHttpArg ? { http: new plugins.http.Agent({ ...lookup, keepAlive: true, timeout: idleSocketTimeoutMs }) } : {}),
+  };
+};
 
 /** Waits until the request can take more body bytes; rejects once it has closed. */
 const drained = (requestArg: InstanceType<typeof plugins.http.ClientRequest>): Promise<void> => new Promise((resolve, reject) => {
@@ -160,17 +178,17 @@ export const sendNodeRequest = (url: URL, requestArg: INodeRequest): Promise<INo
   });
 });
 
+/** `sendNodeRequest` through `agentsArg` as a transport: a GET, or a POST of the body. */
+export const createAgentTransport = (agentsArg: INodeRequestAgents): TForgeTransport => async (url, headers, signal, body, options) => {
+  const { sent: _sent, ...response } = await sendNodeRequest(url, {
+    method: body ? 'POST' : 'GET', headers, body, signal, agents: agentsArg, redirect: options?.redirect,
+  });
+  return response;
+};
+
 /**
  * `node:https` with an owned keep-alive agent whose `ca` list replaces the
  * default trust store for these connections only. The agent unreferences idle
  * sockets, so pooled connections never keep the process alive.
  */
-export const createHttpsTransport = (caCertificates: string[]): TForgeTransport => {
-  const agents = createNodeAgents(caCertificates);
-  return async (url, headers, signal, body, options) => {
-    const { sent: _sent, ...response } = await sendNodeRequest(url, {
-      method: body ? 'POST' : 'GET', headers, body, signal, agents, redirect: options?.redirect,
-    });
-    return response;
-  };
-};
+export const createHttpsTransport = (caCertificates: string[]): TForgeTransport => createAgentTransport(createNodeAgents(caCertificates));

package/ts/index.ts

@@ -487,6 +487,7 @@ export class CodeFeed {
 }
 export * from './classes.forgeinventory.js';
 export * from './classes.forgeinventoryscanner.js';
+export * from './classes.giteasourcefreeze.js';
 export * from './classes.giteasourceinventory.js';
 export * from './classes.giteasourcetransfer.js';
 export * from './classes.lfsbatchclient.js';