ovsx 0.10.1 → 0.10.3

package/src/registry.ts

@@ -12,7 +12,8 @@ import * as http from 'http';
 import * as fs from 'fs';
 import * as querystring from 'querystring';
 import * as followRedirects from 'follow-redirects';
-import { statusError } from './util';
+import { RegistryOptions } from './registry-options';
+import { rejectError, statusError } from './util';
 
 export const DEFAULT_URL = 'https://open-vsx.org';
 export const DEFAULT_NAMESPACE_SIZE = 1024;
@@ -53,17 +54,17 @@ export class Registry {
                 'Content-Type': 'application/json'
             }, this.maxNamespaceSize);
         } catch (err) {
-            return Promise.reject(err);
+            return rejectError(err);
         }
     }
 
     verifyPat(namespace: string, pat: string): Promise<Response> {
-      try {
-          const query: { [key: string]: string } = { token: pat };
-          return this.getJson(this.getUrl(`api/${namespace}/verify-pat`, query));
-      } catch (err) {
-          return Promise.reject(err);
-      }
+        try {
+            const query: { [key: string]: string } = { token: pat };
+            return this.getJson(this.getUrl(`api/${namespace}/verify-pat`, query));
+        } catch (err) {
+            return rejectError(err);
+        }
     }
 
     publish(file: string, pat: string): Promise<Extension> {
@@ -74,7 +75,7 @@ export class Registry {
                 'Content-Type': 'application/octet-stream'
             }, this.maxPublishSize);
         } catch (err) {
-            return Promise.reject(err);
+            return rejectError(err);
         }
     }
 
@@ -86,7 +87,7 @@ export class Registry {
             }
             return this.getJson(this.getUrl(path));
         } catch (err) {
-            return Promise.reject(err);
+            return rejectError(err);
         }
     }
 
@@ -105,11 +106,11 @@ export class Registry {
                 });
                 response.pipe(stream);
             });
-            stream.on('error', err => {
+            stream.on('error', (err: Error) => {
                 request.abort();
                 reject(err);
             });
-            request.on('error', err => {
+            request.on('error', (err: Error) => {
                 stream.close();
                 reject(err);
             });
@@ -144,11 +145,11 @@ export class Registry {
             const requestOptions = this.getRequestOptions('POST', headers, maxBodyLength);
             const request = this.getProtocol(url)
                                 .request(url, requestOptions, this.getJsonResponse<T>(resolve, reject));
-            stream.on('error', err => {
+            stream.on('error', (err: Error) => {
                 request.abort();
                 reject(err);
             });
-            request.on('error', err => {
+            request.on('error', (err: Error) => {
                 stream.close();
                 reject(err);
             });
@@ -171,9 +172,7 @@ export class Registry {
 
     private getRequestOptions(method?: string, headers?: http.OutgoingHttpHeaders, maxBodyLength?: number): http.RequestOptions {
         if (this.username && this.password) {
-            if (!headers) {
-                headers = {};
-            }
+            headers ??= {};
             const credentials = Buffer.from(this.username + ':' + this.password).toString('base64');
             headers['Authorization'] = 'Basic ' + credentials;
         }
@@ -219,33 +218,6 @@ export class Registry {
 
 }
 
-export interface RegistryOptions {
-    /**
-     * The base URL of the registry API.
-     */
-    registryUrl?: string;
-    /**
-     * Personal access token.
-     */
-    pat?: string;
-    /**
-     * User name for basic authentication.
-     */
-    username?: string;
-    /**
-     * Password for basic authentication.
-     */
-    password?: string;
-    /**
-     * Maximal request body size for creating namespaces.
-     */
-    maxNamespaceSize?: number;
-    /**
-     * Maximal request body size for publishing.
-     */
-    maxPublishSize?: number;
-}
-
 export interface Response {
     success?: string;
     warning?: string;

package/src/store.ts

@@ -1,3 +1,12 @@
+/********************************************************************************
+ * Copyright (c) 2024 Precies. Software and others
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ ********************************************************************************/
 import * as fs from 'fs';
 import * as path from 'path';
 import { homedir } from 'os';

package/src/util.ts

@@ -13,27 +13,15 @@ import * as path from 'path';
 import * as tmp from 'tmp';
 import * as http from 'http';
 import * as readline from 'readline';
-import { RegistryOptions } from './registry';
-import { VerifyPatOptions, doVerifyPat } from './verify-pat';
-import { PublishOptions } from './publish';
-import { openDefaultStore } from './store';
-import { CreateNamespaceOptions } from './create-namespace';
+import { RegistryOptions } from './registry-options';
 
 export { promisify } from 'util';
 
 export function addEnvOptions(options: RegistryOptions): void {
-    if (!options.registryUrl) {
-        options.registryUrl = process.env.OVSX_REGISTRY_URL;
-    }
-    if (!options.pat) {
-        options.pat = process.env.OVSX_PAT;
-    }
-    if (!options.username) {
-        options.username = process.env.OVSX_USERNAME;
-    }
-    if (!options.password) {
-        options.password = process.env.OVSX_PASSWORD;
-    }
+    options.registryUrl ??= process.env.OVSX_REGISTRY_URL;
+    options.pat ??= process.env.OVSX_PAT;
+    options.username ??= process.env.OVSX_USERNAME;
+    options.password ??= process.env.OVSX_PASSWORD;
 }
 
 export function matchExtensionId(id: string): RegExpExecArray | null {
@@ -51,7 +39,7 @@ export function makeDirs(path: fs.PathLike): Promise<void> {
         if (fs.existsSync(path)) {
             resolve();
         } else {
-            fs.mkdir(path, { recursive: true }, err => {
+            fs.mkdir(path, { recursive: true }, (err: NodeJS.ErrnoException | null) => {
                 if (err)
                     reject(err);
                 else
@@ -63,7 +51,7 @@ export function makeDirs(path: fs.PathLike): Promise<void> {
 
 export function createTempFile(options: tmp.TmpNameOptions): Promise<string> {
     return new Promise((resolve, reject) => {
-        tmp.tmpName(options, (err, name) => {
+        tmp.tmpName(options, (err: Error | null, name: string) => {
             if (err)
                 reject(err);
             else
@@ -72,6 +60,11 @@ export function createTempFile(options: tmp.TmpNameOptions): Promise<string> {
     });
 }
 
+export function rejectError(err: any) {
+    const reason = err instanceof Error ? err : new Error(String(err));
+    return Promise.reject(reason);
+}
+
 export function handleError(debug?: boolean, additionalMessage?: string, exit: boolean = true): (reason: any) => void {
     return reason => {
         if (reason instanceof Error && !debug) {
@@ -105,7 +98,7 @@ export function readFile(name: string, packagePath?: string, encoding: BufferEnc
         fs.readFile(
             path.join(packagePath ?? process.cwd(), name),
             { encoding },
-            (err, content) => {
+            (err: NodeJS.ErrnoException | null, content: string) => {
                 if (err) {
                     reject(err);
                 } else {
@@ -139,7 +132,7 @@ export function writeFile(name: string, content: string, packagePath?: string, e
             path.join(packagePath ?? process.cwd(), name),
             content,
             { encoding },
-            err => {
+            (err: NodeJS.ErrnoException | null) => {
                 if (err) {
                     reject(err);
                 } else {
@@ -186,30 +179,4 @@ export async function getUserChoice<R extends string>(text: string, values: R[],
         }
     }
     return defaultValue;
-}
-
-export async function requestPAT(namespace: string, options: CreateNamespaceOptions | PublishOptions | VerifyPatOptions, verify: boolean = true): Promise<string> {
-    const pat = await getUserInput(`Personal Access Token for namespace '${namespace}':`);
-    if (verify) {
-        await doVerifyPat({ ...options, namespace, pat });
-    }
-
-    return pat;
-}
-
-export async function getPAT(namespace: string, options: CreateNamespaceOptions | PublishOptions | VerifyPatOptions, verify: boolean = true): Promise<string> {
-    if (options?.pat) {
-        return options.pat;
-    }
-
-    const store = await openDefaultStore();
-    let pat = store.get(namespace);
-    if (pat) {
-        return pat;
-    }
-
-    pat = await requestPAT(namespace, options, verify);
-    await store.add(namespace, pat);
-
-    return pat;
 }

package/src/verify-pat-options.ts

@@ -0,0 +1,18 @@
+/********************************************************************************
+ * Copyright (c) 2022 Anibal Solon and others
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ ********************************************************************************/
+
+import { RegistryOptions } from './registry-options';
+
+export interface VerifyPatOptions extends RegistryOptions {
+    /**
+     * Name of the namespace.
+     */
+    namespace?: string
+}

package/src/verify-pat.ts

@@ -8,8 +8,9 @@
  * SPDX-License-Identifier: EPL-2.0
  ********************************************************************************/
 
-import { Registry, RegistryOptions } from './registry';
-import { readManifest, addEnvOptions, getPAT } from './util';
+import { getPAT, doVerifyPat } from './pat';
+import { readManifest, addEnvOptions } from './util';
+import { VerifyPatOptions } from './verify-pat-options';
 
 /**
  * Validates that a Personal Access Token can publish to a namespace.
@@ -35,21 +36,3 @@ export async function verifyPat(options: VerifyPatOptions): Promise<void> {
     options.pat = await getPAT(options.namespace, options, false);
     await doVerifyPat(options);
 }
-
-export async function doVerifyPat(options: VerifyPatOptions) {
-    const registry = new Registry(options);
-    const namespace = options.namespace as string;
-    const pat = options.pat as string;
-    const result = await registry.verifyPat(namespace, pat);
-    if (result.error) {
-        throw new Error(result.error);
-    }
-    console.log(`\ud83d\ude80  PAT valid to publish at ${namespace}`);
-}
-
-export interface VerifyPatOptions extends RegistryOptions {
-    /**
-     * Name of the namespace.
-     */
-    namespace?: string
-}

package/src/version.ts

@@ -1 +1 @@
-export const LIB_VERSION = "0.10.1";
+export const LIB_VERSION = "0.10.3";

package/src/zip.ts

@@ -1,4 +1,13 @@
-import { Entry, open, ZipFile } from 'yauzl';
+/********************************************************************************
+ * Copyright (c) 2024 Precies. Software and others
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ ********************************************************************************/
+import * as yauzl from 'yauzl-promise';
 import { Readable } from 'stream';
 import { Manifest } from './util';
 
@@ -11,37 +20,23 @@ async function bufferStream(stream: Readable): Promise<Buffer> {
 	});
 }
 
-export async function readZip(packagePath: string, filter: (name: string) => boolean): Promise<Map<string, Buffer>> {
-	const zipfile = await new Promise<ZipFile>((resolve, reject) =>
-		open(packagePath, { lazyEntries: true }, (err, zipfile) => (err ? reject(err) : resolve(zipfile)))
-	);
-
-	return await new Promise((resolve, reject) => {
-		const result = new Map<string, Buffer>();
-
-		zipfile.once('close', () => resolve(result));
-
-		zipfile.readEntry();
-		zipfile.on('entry', (entry: Entry) => {
-			const name = entry.fileName.toLowerCase();
-
+async function readZip(packagePath: string, filter: (name: string) => boolean): Promise<Map<string, Buffer>> {
+	const result = new Map<string, Buffer>();
+	const zipfile = await yauzl.open(packagePath);
+	try {
+		for await (const entry of zipfile) {
+			const name = entry.filename.toLowerCase();
 			if (filter(name)) {
-				zipfile.openReadStream(entry, (err, stream) => {
-					if (err) {
-						zipfile.close();
-						return reject(err);
-					}
-
-					bufferStream(stream).then(buffer => {
-						result.set(name, buffer);
-						zipfile.readEntry();
-					});
-				});
-			} else {
-				zipfile.readEntry();
+				const stream = await zipfile.openReadStream(entry);
+				const buffer = await bufferStream(stream);
+				result.set(name, buffer);
 			}
-		});
-	});
+		}
+	} finally {
+		await zipfile.close();
+	}
+
+	return result;
 }
 
 export async function readVSIXPackage(packagePath: string): Promise<Manifest> {
@@ -51,5 +46,5 @@ export async function readVSIXPackage(packagePath: string): Promise<Manifest> {
 		throw new Error('Manifest not found.');
 	}
 
-    return JSON.parse(rawManifest.toString('utf8')) as Manifest;
+	return JSON.parse(rawManifest.toString('utf8')) as Manifest;
 }