npm package discovery and stats viewer.

Discover Tips

  • General search

    [free text search, go nuts!]

  • Package details

    pkg:[package-name]

  • User packages

    @[username]

Sponsor

Optimize Toolset

I’ve always been into building performant and accessible sites, but lately I’ve been taking it extremely seriously. So much so that I’ve been building a tool to help me optimize and monitor the sites that I build to make sure that I’m making an attempt to offer the best experience to those who visit them. If you’re into performant, accessible and SEO friendly sites, you might like it too! You can check it out at Optimize Toolset.

About

Hi, 👋, I’m Ryan Hefner  and I built this site for me, and you! The goal of this site was to provide an easy way for me to check the stats on my npm packages, both for prioritizing issues and updates, and to give me a little kick in the pants to keep up on stuff.

As I was building it, I realized that I was actually using the tool to build the tool, and figured I might as well put this out there and hopefully others will find it to be a fast and useful way to search and browse npm packages as I have.

If you’re interested in other things I’m working on, follow me on Twitter or check out the open source projects I’ve been publishing on GitHub.

I am also working on a Twitter bot for this site to tweet the most popular, newest, random packages from npm. Please follow that account now and it will start sending out packages soon–ish.

Open Software & Tools

This site wouldn’t be possible without the immense generosity and tireless efforts from the people who make contributions to the world and share their work via open source initiatives. Thank you 🙏

© 2024 – Pkg Stats / Ryan Hefner

@aller/cyclops-frontend-api

v2.8.0

Published

Cyclops frontend API

Downloads

1,803

Readme

cyclops-frontend-api

API-part of the cyclops-frontend. This package contains all non-DOM changes, and interactions with CYCLOPS, from login, to payment-initiations, to user-fetching and whatnot. Below are more content and info on functions, schemas, interfaces that are being used in this package..

This package used to use Ajv for response-validation of the json schema. This package, it's validation vs unvalidated functions and tests have been removed to allow the client more controll of the response.

When fetching a user through /users/me a cyclops_seg cookie is set, if the user has adSegments as a property.

Please note that this library is still in active development..

Table of Contents

Design

Interfaces can be found in ./src/**/interface.ts.

Using the package

If you are not afraid of bloat, this package can be used with @aller/cyclops-frontend-api. If you are afraid of bloat, everything can be referenced with @aller/cyclops-frontend-api/lib/node|client/** (e.g. @aller/cyclops-frontend-api/lib/user/login). In this, you'll only include the parts of code you actually need, instead of the whole package.

For packages that require node-like environment-transpiled code, point to the lib/node folder, while client-side code should point to lib/client.

Functions

User

/**
 * Get the current (possibly-cached) user based on
 * the cyclops-session cookie
 * Use this function if you want to check if a user is logged.
 */

async getCurrentUser(
    domain: string = '',
    options?: any
): Promise<IUser>
/**
 * Get the current non-cached user based on the
 * cyclops-session cookie
 * This function has a performance cost and should only be used
 * if the exact state of the user is required (minside)
 */

async getCannonicalUser(
    domain: string = '',
    options?: any
): Promise<IUser>
/**
 * Sends a subscribe request to cyclops
 */

async subscribe(
  productId: string,
  accessCode: string,
  dealId: string,
  options?: any,
): Promise<boolean>
/**
 * Get the current (possibly-cached) user
 * based on the cyclops-session cookie
 * Use this function if you want to check if a user is logged.
 */

async unsubscribe(
  productId: string,
  domain: string = '',
  options?: any
): Promise<boolean>
/**
 * Initiates a payment for a product, and deal
 */

async initiatePayment(
  productId: string,
  dealId: string,
  options: IPaymentOptions = defaultPaymentOptions,
  domain: string = '',
  fetchOptions?: any
): Promise<IPaymentInitResponse>
/**
 * Gets from cyclops
 */

async cyclopsGet<T>(
  path: string,
  options?: any,
  absoluteUrl?: boolean
): Promise<T>
/**
 * Posts to cyclops
 */


async cyclopsPost<T>(
  path: string,
  data: any,
  options: any = {},
  version?: string,
): Promise<T> =>
/**
 * Sends a delete request to cyclops
 */

async cyclopsDelete<T>(
  path: string,
  data: any,
  options: any = {},
): Promise<T>
/**
 * Initiates a cyclops login redirect. Redirect parameter
 * says whether to add a redirect url
 */

cyclopsLogin(
    redirect?: string,
    domain: string = '',
    options?: any
)
/**
 * Initiates a cyclops logout
 */

async cyclopsLogout(
    refresh: boolean = false,
    domain: string = '',
    options?: any
)

The listener-system is to allow for listening to requests being made to certain endpoints, in case you want a reactive component, be reactive on a separate component without a bunch of hacks

import { addListener, removeListener } from '@aller/cyclops-frontend-api/lib/client/cyclops/listener'

const listenerFunction = (event:CustomEvent) => {
  if(!event.detail) {
    return
  }

  DO YOUR STUFF HERE
}

addListener(ENDPOINT_URL_GOES_HERE, listenerFunction)


// Handle event, then remove
removeListener(ENDPOINT_URL_GOES_HERE, listenerFunction)
/**
 * Gets catalogue and validates the response
 * to be valid ICatalogue
 */

async getCatalogue(
  domain: string = '',
  options?: any
): Promise<ICatalogue>

Constants

/**
 * Creates relative loginURL
 */

export const cyclopsLoginRelativeURL = (
  redirect?: string,
  domain: string = '',
  options?: any,
): string => {
  const red = redirect ? redirect : window.location.pathname;
  const relativeUrl = `${domain}${CYCLOPS_API}/login?cyclops-redirect=${red}`;
  return relativeUrl;
};
/**
 * Creates relative loginURL without utilizing any window
 * or document elements
 */

export const cyclopsLoginRelativeURLServer = (
  redirect?: string,
  domain: string = '',
  options?: any,
): string => {
  const red = redirect ? `?cyclops-redirect=${redirect}` : '';
  const relativeUrl = `${domain}${CYCLOPS_API}/${red}`;
  return relativeUrl;
};

Interfaces

interface IUser {
  readonly cyclopsId: string;
  readonly mediaConnectId: string;
  readonly aid: string;
  readonly email: string;
  readonly fullName: string;
  readonly phoneNumber: string;
  readonly subscriptions?: ReadonlyArray<ISubscription>;
  readonly newsletters?: ReadonlyArray<INewsletter>;
  readonly legacySubscriptions?: ReadonlyArray<ILegacySubscription>;
  readonly paymentHistory: IPaymentHistory;
  readonly adSegments?: ReadonlyArray<string>;
  readonly consents?: ReadonlyArray<IConsentType>;
  readonly newsletterPreferences?: ReadonlyArray<INewsLetterPreference>;
  readonly mobileSubscriptions?: IMobileSubscription[];
}
interface IBaseSubscription {
  readonly productId: string;
  readonly status: 'ACTIVE' | 'CANCELLED';
}

interface ISubscription extends IBaseSubscription {
  readonly endDate?: string;
  readonly subscriptionId?: string;
  readonly startDate?: string;
  readonly nextChargeDate?: string;
  readonly chargeAmount?: number;
  readonly chargeInterval?: string;
  readonly dealId?: string;
}

interface ILegacySubscription extends IBaseSubscription {}

interface IMobileSubscription extends IBaseSubscription {
  readonly endDate?: string;
  readonly subscriptionId?: string;
  readonly startDate?: string;
  readonly dealId?: string;
  readonly dataGb?: string;
  readonly phoneNumber?: string;
  readonly signupDate?: string;
  readonly chargeAmount?: number;
  readonly chargeInterval?: string;
}
interface INewsletter {
  readonly newsletterId: string;
  readonly site: string;
}
interface IProduct {
  readonly productName: string;
  readonly productDescription: string;
  readonly productId: string;
  readonly productLogo: string;
  readonly productType: 'digital' | 'print';
  readonly deals: ReadonlyArray<IProductDeal>;
}
interface IProductDeal {
  readonly dealName: string;
  readonly dealDescription: string;
  readonly dealId: string;
  readonly dealLogo: string;
  readonly fullTermsDescription: string;
}
type TPaymentProvider = 'vipps' | 'nets';
interface IPaymentInitRequest {
  productId: string;
  dealId: string;
  embeddedCheckoutUrl: string;
  allowUnauthenticatedCheckout: boolean;
  paymentProvider?: TPaymentProvider;
  redirectURL?: string;
}
interface IPaymentInitResponse {
  paymentId: string;
  paymentProvider: TPaymentProvider;
  reservationId?: string;
  confirmationUrl?: string;
}
interface IPaymentOptions {
  allowUnauthenticatedCheckout?: boolean;
  embeddedCheckoutUrl?: string;
  paymentProvider?: TPaymentProvider;
  redirectURL?: string;
}
interface ICatalogue {
  readonly brands: ReadonlyArray<IBrand>;
}
interface IBrand {
  readonly brandName: string;
  readonly brandDescription: string;
  readonly brandId: string;
  readonly brandLogo: string;
  readonly products: ReadonlyArray<IProduct>;
}