@or-sdk/library 0.1.0-beta.1912.0

package/src/Library.ts

@@ -0,0 +1,506 @@
+import { Base } from '@or-sdk/base';
+import {
+  SERVICE_KEY,
+  INDEX_TYPE,
+} from './constants';
+
+import type {
+  LibraryConfig,
+  OptionalParams,
+  CrossEnvOptionalParams,
+  IsPlaygroundParam,
+} from './types';
+
+import {
+  CategoryItemResponseDTO,
+  CategoryListResponseDTO,
+  CreateCategoryBodyDTO,
+  CreatePackageByVersionBodyDTO,
+  CreatePackageByVersionResponseDTO,
+  CreatePackageReleaseBodyDTO,
+  CreateReleaseParamsDTO,
+  GetPackageArchiveSignedUrlDTO,
+  GetPackageByIdQueryUnionDTO,
+  GetPackageByIdResponseDTO,
+  GetPackageResponseDTO,
+  GetPackagesQueryDTO,
+  GetPackagesResponseDTO,
+  PackageParamNpmScopeDTO,
+  PackageParamUniversalDTO,
+  PutLegacyVersionResponseDTO,
+  SyncLegacyResponseDTO,
+  PutLegacyPackageBodyDTO,
+  DeprecateLegacyStepsBodyDTO,
+  PackageTypeEnum,
+  PackageStatusDetailsStatusEnum,
+} from '@or-sdk/library-types-v1';
+
+export class Library extends Base {
+  private readonly packageType: PackageTypeEnum;
+
+  /**
+   * ```typescript
+   * import { Library } from '@or-sdk/library';
+   * import config from '../config';
+   *
+   * const LibrarySDK = new Library({
+   *   token: 'my-account-token-string',
+   *   libraryApiUrl: config.LIBRARY_API_URL
+   * });
+   * ```
+   */
+  constructor(params: LibraryConfig) {
+    const { token, discoveryUrl, packageType, libraryApiUrl } = params;
+
+    super({
+      discoveryUrl,
+      token,
+      serviceKey: SERVICE_KEY,
+      serviceUrl: libraryApiUrl,
+      useDefaultSerializer: false,
+    });
+
+    this.packageType = packageType;
+  }
+
+  /**
+   * List all packages
+   */
+  async getPackages(
+    params: GetPackagesQueryDTO,
+    { type, signal }: OptionalParams = {}
+  ): Promise<GetPackagesResponseDTO> {
+    const packageType = type ?? this.packageType;
+
+    return this.callApiV2({
+      route: `/api/v1/packages/${packageType}`,
+      signal,
+      params,
+    });
+  }
+
+  /**
+   * List all packages from the playground
+   */
+  async getPlayground(
+    params: GetPackagesQueryDTO,
+    { type, signal }: OptionalParams = {}
+  ): Promise<GetPackagesResponseDTO> {
+    const packageType = type ?? this.packageType;
+
+    return this.callApiV2({
+      route: `/api/v1/playground/${packageType}`,
+      signal,
+      params,
+    });
+  }
+
+  /**
+   * List all categories
+   */
+  async getCategories(
+    params = {},
+    { type, signal }: OptionalParams = {}
+  ): Promise<CategoryListResponseDTO> {
+    const packageType = type || this.packageType;
+
+    return this.callApiV2({
+      route: `/api/v1/categories/${packageType}`,
+      signal,
+      params,
+    });
+  }
+
+  /**
+   * Upsert given category
+   */
+  async putCategory(
+    data: CreateCategoryBodyDTO,
+    { type, signal, customHeaders }: CrossEnvOptionalParams = {}
+  ): Promise<CategoryItemResponseDTO> {
+    const packageType = type ?? this.packageType;
+
+    return this.callApiV2({
+      method: 'PUT',
+      route: `/api/v1/categories/${packageType}`,
+      data,
+      signal,
+      customHeaders,
+    });
+  }
+
+  /**
+   * Get category by ID
+   */
+  async getCategoryById(
+    { id }: Pick<PackageParamUniversalDTO, 'id'>,
+    { type, signal }: OptionalParams = {}
+  ): Promise<CategoryItemResponseDTO> {
+    const packageType = type ?? this.packageType;
+
+    return this.callApiV2({
+      route: `/api/v1/categories/${packageType}/id/${id}`,
+      signal,
+    });
+  }
+
+  /**
+   * Get credentials for uploading the package
+   * ```typescript
+   * const result = await libraryApi.getUploadCredentials({ id: 'id', version: 'version' });
+   * ```
+   */
+  public async getUploadCredentials(
+    data: CreatePackageByVersionBodyDTO & PackageParamUniversalDTO & PackageParamNpmScopeDTO,
+    { type, signal, customHeaders }: CrossEnvOptionalParams = {}
+  ): Promise<CreatePackageByVersionResponseDTO> {
+    const packageType = type ?? this.packageType;
+    const { id, version } = data;
+
+    return this.callApiV2({
+      method: 'POST',
+      route: `/api/v1/packages/${packageType}/id/${id}/version/${version}`,
+      data,
+      customHeaders,
+      signal,
+    });
+  }
+
+  /**
+   * Get credentials for uploading the package to the playground (playground)
+   */
+  async getUploadCredentialsPlayground(
+    data: CreatePackageByVersionBodyDTO & PackageParamUniversalDTO & PackageParamNpmScopeDTO,
+    { type, signal }: OptionalParams = {}
+  ): Promise<CreatePackageByVersionResponseDTO> {
+    const packageType = type ?? this.packageType;
+    const { id, version } = data;
+
+    return this.callApiV2({
+      method: 'POST',
+      route: `/api/v1/playground/${packageType}/id/${id}/version/${version}`,
+      data,
+      signal,
+    });
+  }
+
+  /**
+   * List all versions of given package
+   */
+  async getVersions(
+    { id, isPlayground, ...params }: Pick<PackageParamUniversalDTO, 'id' | 'type'> &
+    GetPackageByIdQueryUnionDTO & IsPlaygroundParam,
+    { type, signal }: OptionalParams = {}
+  ): Promise<GetPackageByIdResponseDTO> {
+    const packageType = type ?? this.packageType;
+    const index = isPlayground ? INDEX_TYPE.PLAYGROUND : INDEX_TYPE.PACKAGES;
+
+    return this.callApiV2({
+      route: `/api/v1/${index}/${packageType}/id/${id}`,
+      signal,
+      params,
+    });
+  }
+
+  /**
+   * Delete given package version from playground
+   */
+  async deletePackageVersionFromPlayground(
+    { id, version }: Pick<PackageParamUniversalDTO, 'id' | 'version'>,
+    { type, signal }: OptionalParams = {}
+  ) {
+    const packageType = type ?? this.packageType;
+
+    return this.callApiV2({
+      method: 'DELETE',
+      route: `/api/v1/playground/${packageType}/id/${id}/version/${version}`,
+      signal,
+    });
+  }
+
+  /**
+   * Get the latest version of the package meta by ID
+   */
+  async getPackageMetaLatestVersionById(
+    { id }: Pick<PackageParamUniversalDTO, 'id'>,
+    { type, signal }: OptionalParams = {}
+  ): Promise<GetPackageResponseDTO> {
+    const packageType = type ?? this.packageType;
+
+    return this.callApiV2({
+      route: `/api/v1/packages/${packageType}/id/${id}/latest`,
+      signal,
+    });
+  }
+
+  /**
+   * Get download package archive url
+   * ```typescript
+   * const result = await libraryApi.getMetaByVersion({ id: 'id', version: 'version', isPlayground: false });
+   * ```
+   */
+  async getMetaByVersion(
+    { id, version, isPlayground }: Pick<PackageParamUniversalDTO, 'id' | 'version'> & IsPlaygroundParam,
+    { signal, customHeaders, type }: CrossEnvOptionalParams = {}
+  ) {
+    const packageType = type ?? this.packageType;
+    const index = isPlayground ? INDEX_TYPE.PLAYGROUND : INDEX_TYPE.PACKAGES;
+
+    return this.callApiV2({
+      method: 'GET',
+      route: `/api/v1/${index}/${packageType}/id/${id}/version/${version}`,
+      customHeaders,
+      signal,
+    });
+  }
+
+  /**
+   * List favorites
+   */
+  async getFavorites(
+    params: GetPackagesQueryDTO,
+    { type, signal }: OptionalParams = {}
+  ): Promise<GetPackagesResponseDTO> {
+    const packageType = type ?? this.packageType;
+
+    return this.callApiV2({
+      route: `/api/v1/packages/${packageType}/favorites`,
+      signal,
+      params,
+    });
+  }
+
+  /**
+   * Submit legacy Step Template to Library API
+   */
+  async submitLegacyStepJson(
+    legacyStepTemplate: PutLegacyPackageBodyDTO & Pick<PackageParamUniversalDTO, 'id' | 'version'>,
+    { signal }: Pick<OptionalParams, 'signal'> = {}
+  ): Promise<SyncLegacyResponseDTO> {
+    const packageType = PackageTypeEnum.STEP;
+    const { id, version = '0.0.1' } = legacyStepTemplate;
+    const data = {
+      data: legacyStepTemplate,
+      name: legacyStepTemplate.name,
+      description: legacyStepTemplate.description,
+      categories: legacyStepTemplate.categories,
+    };
+
+    return this.callApiV2({
+      method: 'PUT',
+      route: `/api/v1/service/sync/${packageType}/legacy/id/${id}/version/${version}/json`,
+      data,
+      signal,
+    });
+  }
+
+  /**
+   * Get legacy Step Template from Library API
+   */
+  async getLegacyStepJson(
+    { id, version }: Pick<PackageParamUniversalDTO, 'id' | 'version'>,
+    { signal }: Pick<OptionalParams, 'signal'> = {}
+  ): Promise<GetPackageResponseDTO> {
+    const packageType = PackageTypeEnum.STEP;
+
+    return this.callApiV2({
+      route: `/api/v1/packages/${packageType}/id/${id}/version/${version}/json`,
+      signal,
+    });
+  }
+
+  /**
+   * Sync legacy Step Templates from playground Account
+   */
+  async syncLegacyStepFromLibrary(
+    { id }: Pick<PackageParamUniversalDTO, 'id'>,
+    { signal }: Pick<OptionalParams, 'signal'> = {}
+  ): Promise<SyncLegacyResponseDTO> {
+    const packageType = 'STEP';
+
+    return this.callApiV2({
+      method: 'PUT',
+      route: `/api/v1/service/sync/${packageType}/legacy/id/${id}/latest`,
+      signal,
+    });
+  }
+
+  /**
+   * Set release status
+   */
+  async setReleaseStatus(
+    data: CreateReleaseParamsDTO & CreatePackageReleaseBodyDTO,
+    { type, signal }: OptionalParams = {}
+  ): Promise<boolean> {
+    const packageType = type ?? this.packageType;
+    const { id, version } = data;
+    const { level } = data;
+
+    delete data.level;
+
+    return this.callApiV2({
+      method: 'POST',
+      route: `/api/v1/packages/${packageType}/id/${id}/version/${version}/status/release/${level}`,
+      data,
+      signal,
+    });
+  }
+
+  /**
+   * Set release status to BETA
+   */
+  async setReleaseStatusToBeta(
+    data: CreateReleaseParamsDTO,
+    { type, signal }: OptionalParams = {}
+  ): Promise<boolean> {
+    const status = PackageStatusDetailsStatusEnum.BETA;
+
+    return this.setReleaseStatus({
+      ...data,
+      status,
+    }, {
+      type,
+      signal,
+    });
+  }
+
+  /**
+   * Set release status to RELEASED
+   */
+  async setReleaseStatusToReleased(
+    data: CreateReleaseParamsDTO,
+    { type, signal }: OptionalParams = {}
+  ): Promise<boolean> {
+    const status = PackageStatusDetailsStatusEnum.RELEASED;
+
+    return this.setReleaseStatus({
+      ...data,
+      status,
+    }, {
+      type,
+      signal,
+    });
+  }
+
+  /**
+   * Set release status to DEPRECATED
+   */
+  async setReleaseStatusToDeprecated(
+    data: CreateReleaseParamsDTO,
+    { type, signal }: OptionalParams = {}
+  ): Promise<boolean> {
+    const status = PackageStatusDetailsStatusEnum.DEPRECATED;
+
+    return this.setReleaseStatus({
+      ...data,
+      status,
+    }, {
+      type,
+      signal,
+    });
+  }
+
+  /**
+   * Deprecate legacy Step Template
+   */
+  async deprecateLegacyStep(
+    data: CreateReleaseParamsDTO,
+    { signal }: Pick<OptionalParams, 'signal'> = {}
+  ): Promise<boolean> {
+    const type = 'STEP';
+
+    return this.setReleaseStatusToDeprecated(data, {
+      type,
+      signal,
+    });
+  }
+
+  /**
+   * Deprecate multiple legacy Step Templates
+   */
+  async deprecateLegacySteps(
+    data: DeprecateLegacyStepsBodyDTO,
+    { signal }: Pick<OptionalParams, 'signal'> = {}
+  ) {
+    return this.callApiV2({
+      method: 'POST',
+      route: '/api/v1/service/sync/STEP/legacy/deprecate',
+      data,
+      signal,
+    });
+  }
+
+  /**
+   * Get download package archive url
+   * ```typescript
+   * const result = await libraryApi.getDownloadArchiveCredentials({ id: 'id', version: 'version' });
+   * ```
+   */
+  public async getDownloadArchiveCredentials(
+    { id, version }: Pick<PackageParamUniversalDTO, 'id' | 'version'>,
+    { signal, customHeaders }: CrossEnvOptionalParams = {}
+  ): Promise<GetPackageArchiveSignedUrlDTO> {
+    return this.callApiV2({
+      method: 'GET',
+      route: `/api/v1/packages/${this.packageType}/id/${id}/version/${version}/archive`,
+      customHeaders,
+      signal,
+    });
+  }
+
+  /**
+   * Sync inputs from global library to specific env
+   * ```typescript
+   * const result = await libraryApi.syncInputFromLibrary({ id: 'id', version: 'version' });
+   * ```
+   */
+  async syncInputFromLibrary(
+    { id, version }: Pick<PackageParamUniversalDTO, 'id' | 'version'>,
+    { signal, customHeaders }: CrossEnvOptionalParams = {}
+  ): Promise<PutLegacyVersionResponseDTO> {
+    return this.callApiV2({
+      method: 'PUT',
+      route: `/api/v1/service/sync/${this.packageType}/id/${id}/version/${version}`,
+      customHeaders,
+      signal,
+    });
+  }
+
+  /**
+   * Get new packages
+   * ```typescript
+   * const result = await libraryApi.getNewPackages({size}, {customHeaders: {Auth: 'token'}});)
+   * ```
+   */
+  async getNewPackages(
+    params: GetPackagesQueryDTO,
+    { signal, customHeaders }: CrossEnvOptionalParams = {}
+  ): Promise<GetPackagesResponseDTO> {
+    return this.callApi({
+      method: 'GET',
+      route: `/api/v1/packages/${this.packageType}/new`,
+      params,
+      customHeaders,
+      signal,
+    });
+  }
+
+  /**
+     * Get popular packages
+     * ```typescript
+     * const result = await libraryApi.getNewPackages({size}, {customHeaders: {Auth: 'token'}});)
+     * ```
+     */
+  async getPopularPackages(
+    params: GetPackagesQueryDTO,
+    { signal, customHeaders }: CrossEnvOptionalParams = {}
+  ): Promise<GetPackagesResponseDTO> {
+    return this.callApi({
+      method: 'GET',
+      route: `/api/v1/packages/${this.packageType}/popular`,
+      params,
+      customHeaders,
+      signal,
+    });
+  }
+}

package/src/constants.ts

@@ -0,0 +1,8 @@
+export const SERVICE_KEY = 'library-api';
+export const LIBRARY_SERVICE_KEY = SERVICE_KEY;
+export const LIBRARY_API_URL_KEY = 'LIBRARY_API_URL';
+
+export const INDEX_TYPE = {
+  PACKAGES: 'packages',
+  PLAYGROUND: 'playground',
+} as const;

package/src/index.ts

@@ -0,0 +1,9 @@
+export { Library } from './Library';
+export * from './types';
+export * from './constants';
+export type {
+  PackageSchemaTypeEnum,
+  PackageStatusDetailsLevelEnum,
+  PackageStatusDetailsStatusEnum,
+  PackageTypeEnum,
+} from '@or-sdk/library-types-v1';

package/src/types.ts

@@ -0,0 +1,40 @@
+import { Token, CustomHeaders } from '@or-sdk/base';
+import { PackageTypeEnum } from '@or-sdk/library-types-v1/dist';
+
+export type LibraryConfig = {
+  /**
+   * token
+   */
+  token: Token;
+
+  /**
+   * Url of OneReach service discovery api
+   */
+  discoveryUrl?: string;
+
+  /**
+   * Url of OneReach Library api
+   */
+  libraryApiUrl?: string;
+
+  /**
+   * Package type
+   */
+  packageType: PackageTypeEnum;
+};
+
+export type OptionalParams = {
+  type?: PackageTypeEnum;
+  signal?: AbortSignal;
+};
+
+export type CrossEnvOptionalParams = OptionalParams & {
+  customHeaders?: CustomHeaders;
+};
+
+export type IsPlaygroundParam = {
+  /**
+   * isPlayground property
+   */
+  isPlayground?: boolean;
+};

package/tsconfig.dev.json

@@ -0,0 +1,8 @@
+{
+  "extends": "./tsconfig.esm.json",
+  "compilerOptions": {
+    "declarationDir": "./dist/types",
+    "rootDir": "./src",
+    "declaration": true
+  }
+}

package/tsconfig.esm.json

@@ -0,0 +1,12 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "outDir": "./dist/esm",
+    "declarationDir": "./dist/types",
+    "module": "ES6",
+    "target": "es6",
+    "rootDir": "./src",
+    "declaration": true,
+    "declarationMap": true
+  }
+}

package/tsconfig.json

@@ -0,0 +1,7 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "outDir": "./dist/cjs",
+    "rootDir": "./src"
+  }
+}

package/tsconfig.types.json

@@ -0,0 +1,10 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "declarationDir": "./dist/types",
+    "rootDir": "./src",
+    "declaration": true,
+    "declarationMap": true,
+    "emitDeclarationOnly": true
+  }
+}