@verdaccio/types 11.0.0-6-next.12 → 11.0.0-6-next.13

package/src/plugins/auth.ts

@@ -0,0 +1,22 @@
+import { Callback, HttpError, RemoteUser } from '../commons';
+import { Config } from '../configuration';
+
+export interface AuthPluginPackage {
+  packageName: string;
+  packageVersion?: string;
+  tag?: string;
+}
+
+export type AuthError = HttpError & { code: number };
+export type AuthAccessCallback = (error: AuthError | null, access: boolean) => void;
+export type AuthCallback = (error: AuthError | null, groups: string[] | false) => void;
+
+// @deprecated use IBasicAuth from @verdaccio/auth
+export interface IBasicAuth<T> {
+  config: T & Config;
+  aesEncrypt(buf: Buffer): Buffer;
+  authenticate(user: string, password: string, cb: Callback): void;
+  changePassword(user: string, password: string, newPassword: string, cb: Callback): void;
+  allow_access(pkg: AuthPluginPackage, user: RemoteUser, callback: Callback): void;
+  add_user(user: string, password: string, cb: Callback): any;
+}

package/src/plugins/commons.ts

@@ -0,0 +1,15 @@
+import { Config, Logger } from '../configuration';
+
+export class Plugin<T> {
+  public constructor(config: T, options: PluginOptions<T>) {}
+}
+
+export interface IPlugin<T> {
+  // TODO: not used on core yet
+  version?: string;
+}
+
+export interface PluginOptions<T> {
+  config: T & Config;
+  logger: Logger;
+}

package/src/plugins/filter.ts

@@ -0,0 +1,6 @@
+import { Manifest } from '../manifest';
+import { IPlugin } from './commons';
+
+export interface IPluginStorageFilter<T> extends IPlugin<T> {
+  filter_metadata(packageInfo: Manifest): Promise<Manifest>;
+}

package/src/plugins/index.ts

@@ -0,0 +1,31 @@
+import { RemoteUser } from '../commons';
+import { AllowAccess } from '../configuration';
+import { PackageAccess } from '../manifest';
+import { AuthAccessCallback, AuthCallback } from './auth';
+import { IPlugin } from './commons';
+
+export interface IPluginAuth<T> extends IPlugin<T> {
+  /**
+   * @param props user from Application component
+   */
+  authenticate(user: string, password: string, cb: AuthCallback): void;
+  adduser?(user: string, password: string, cb: AuthCallback): void;
+  changePassword?(user: string, password: string, newPassword: string, cb: AuthCallback): void;
+  allow_publish?(user: RemoteUser, pkg: T & PackageAccess, cb: AuthAccessCallback): void;
+  allow_access?(user: RemoteUser, pkg: T & PackageAccess, cb: AuthAccessCallback): void;
+  allow_unpublish?(user: RemoteUser, pkg: T & PackageAccess, cb: AuthAccessCallback): void;
+  allow_publish?(user: RemoteUser, pkg: AllowAccess & PackageAccess, cb: AuthAccessCallback): void;
+  allow_access?(user: RemoteUser, pkg: AllowAccess & PackageAccess, cb: AuthAccessCallback): void;
+  allow_unpublish?(
+    user: RemoteUser,
+    pkg: AllowAccess & PackageAccess,
+    cb: AuthAccessCallback
+  ): void;
+  apiJWTmiddleware?(helpers: any): Function;
+}
+
+export * from './auth';
+export * from './storage';
+export * from './middleware';
+export * from './commons';
+export * from './filter';

package/src/plugins/middleware.ts

@@ -0,0 +1,8 @@
+import { Config } from '../configuration';
+import { IBasicAuth } from './auth';
+import { IPlugin } from './commons';
+
+// TODO: convert to generic storage should come from implementation
+export interface IPluginMiddleware<T, K> extends IPlugin<T> {
+  register_middlewares(app: any, auth: IBasicAuth<T>, storage: K): void;
+}

package/src/plugins/storage.ts

@@ -0,0 +1,95 @@
+import { PassThrough, PipelinePromise, Readable, Stream, Writable } from 'stream';
+
+import { Callback, CallbackAction, StringValue } from '../commons';
+import { Config, Logger } from '../configuration';
+import { Manifest, MergeTags, Token, Version } from '../manifest';
+import { IPlugin } from './commons';
+
+export type StorageList = string[];
+
+export interface LocalStorage {
+  list: any;
+  secret: string;
+}
+
+export interface ILocalStorage {
+  add(name: string): void;
+  remove(name: string): void;
+  get(): StorageList;
+  sync(): void;
+}
+
+export interface TokenFilter {
+  user: string;
+}
+
+export interface ITokenActions {
+  saveToken(token: Token): Promise<any>;
+  deleteToken(user: string, tokenKey: string): Promise<any>;
+  readTokens(filter: TokenFilter): Promise<Token[]>;
+}
+
+/**
+ * This method expect return a Package object
+ * eg:
+ * {
+ *   name: string;
+ *   time: number;
+ *   ... and other props
+ * }
+ *
+ * The `cb` callback object will be executed if:
+ *  - it might return object (truly)
+ *  - it might reutrn null
+ */
+export type onSearchPackage = (item: Manifest, cb: CallbackAction) => void;
+// FIXME: error should be export type `VerdaccioError = HttpError & { code: number };`
+// but this type is on @verdaccio/commons-api and cannot be used here yet
+export type onEndSearchPackage = (error?: any) => void;
+export type onValidatePackage = (name: string) => boolean;
+
+export type StorageUpdateCallback = (data: Manifest, cb: CallbackAction) => void;
+
+export type StorageWriteCallback = (name: string, json: Manifest, callback: Callback) => void;
+export type PackageTransformer = (pkg: Manifest) => Manifest;
+export type ReadPackageCallback = (err: any | null, data?: Manifest) => void;
+
+export interface ILocalPackageManager {
+  logger: Logger;
+  deletePackage(fileName: string): Promise<void>;
+  removePackage(): Promise<void>;
+  //  next packages migration (this list is meant to replace the callback parent functions)
+  updatePackage(
+    packageName: string,
+    handleUpdate: (manifest: Manifest) => Promise<Manifest>
+  ): Promise<Manifest>;
+  readPackage(name: string): Promise<Manifest>;
+  savePackage(pkgName: string, value: Manifest): Promise<void>;
+  readTarball(pkgName: string, { signal }): Promise<Readable>;
+  createPackage(name: string, manifest: Manifest): Promise<void>;
+  writeTarball(tarballName: string, { signal }): Promise<Writable>;
+  // verify if tarball exist in the storage
+  hasTarball(fileName: string): Promise<boolean>;
+  // verify if package exist in the storage
+  hasPackage(): Promise<boolean>;
+}
+
+export type IPackageStorage = ILocalPackageManager | void;
+
+export type IPluginStorage<T> = ILocalData<T>;
+export type IPackageStorageManager = ILocalPackageManager;
+
+/**
+ * @deprecated use @verdaccio/core pluginUtils instead
+ */
+interface ILocalData<T> extends IPlugin<T>, ITokenActions {
+  logger: Logger;
+  config: T & Config;
+  add(name: string): Promise<void>;
+  remove(name: string): Promise<void>;
+  get(): Promise<any>;
+  init(): Promise<void>;
+  getSecret(): Promise<string>;
+  setSecret(secret: string): Promise<any>;
+  getPackageStorage(packageInfo: string): IPackageStorage;
+}

package/src/search.ts

@@ -0,0 +1,28 @@
+export type PublisherMaintainer = {
+  username: string;
+  email: string;
+};
+
+export type SearchPackageBody = {
+  name: string;
+  scope: string;
+  description: string;
+  author: string | PublisherMaintainer;
+  version: string;
+  keywords: string | string[] | undefined;
+  date: string;
+  links?: {
+    npm: string; // only include placeholder for URL eg: {url}/{packageName}
+    homepage?: string;
+    repository?: string;
+    bugs?: string;
+  };
+  publisher?: any;
+  maintainers?: PublisherMaintainer[];
+};
+
+export type SearchResultWeb = {
+  name: string;
+  version: string;
+  description: string;
+};

package/src/types.ts

@@ -0,0 +1,5 @@
+export * from './plugins';
+export * from './manifest';
+export * from './search';
+export * from './commons';
+export * from './configuration';

package/tsconfig.build.json

@@ -0,0 +1,9 @@
+{
+  "extends": "../../../tsconfig.base.json",
+  "compilerOptions": {
+    "rootDir": "./src",
+    "outDir": "./build"
+  },
+  "include": ["src/**/*"],
+  "exclude": ["src/**/*.test.ts"]
+}

package/tsconfig.json

@@ -0,0 +1,9 @@
+{
+  "extends": "../../../tsconfig.reference.json",
+  "compilerOptions": {
+    "rootDir": "./src",
+    "outDir": "./build"
+  },
+  "include": ["src/**/*"],
+  "exclude": ["src/**/*.test.ts"]
+}

package/typedoc.json

@@ -0,0 +1,5 @@
+{
+  "$schema": "https://typedoc.org/schema.json",
+  "entryPoints": ["src/types.ts"],
+  "sort": ["source-order"]
+}