@qelos/sdk 2.0.22

package/dist/users.js

@@ -0,0 +1,49 @@
+import BaseSDK from './base-gp-sdk';
+export default class GpUsers extends BaseSDK {
+    options;
+    relativePath = '/api/users';
+    constructor(options) {
+        super(options);
+        this.options = options;
+    }
+    getUser(userId) {
+        return this.callJsonApi(`${this.relativePath}/${userId}`);
+    }
+    getList(filters) {
+        return this.callJsonApi(this.relativePath +
+            (filters ?
+                `?${Object.entries(filters).map(([key, value]) => `${key}=${value}`).join('&')}` :
+                ''));
+    }
+    remove(userId) {
+        return this.callApi(`${this.relativePath}/${userId}`, { method: 'delete' });
+    }
+    update(userId, changes) {
+        return this.callJsonApi(`${this.relativePath}/${userId}`, {
+            method: 'put',
+            headers: { 'content-type': 'application/json' },
+            body: JSON.stringify(changes)
+        });
+    }
+    create(user) {
+        return this.callJsonApi(this.relativePath, {
+            method: 'post',
+            headers: { 'content-type': 'application/json' },
+            body: JSON.stringify(user)
+        });
+    }
+    getEncryptedData(userId) {
+        return this.callJsonApi(`${this.relativePath}/${userId}/encrypted`);
+    }
+    async setEncryptedData(userId, data) {
+        const res = await this.callApi(`${this.relativePath}/${userId}/encrypted`, {
+            method: 'post',
+            headers: { 'content-type': 'application/json' },
+            body: JSON.stringify(data)
+        });
+        if (res.status >= 300) {
+            throw new Error('could not set encrypted data');
+        }
+    }
+}
+//# sourceMappingURL=users.js.map

package/dist/users.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"users.js","sourceRoot":"","sources":["../src/users.ts"],"names":[],"mappings":"AACA,OAAO,OAAO,MAAM,eAAe,CAAC;AAWpC,MAAM,CAAC,OAAO,OAAO,OAA0B,SAAQ,OAAO;IAGxC;IAFZ,YAAY,GAAG,YAAY,CAAC;IAEpC,YAAoB,OAA6B;QAC/C,KAAK,CAAC,OAAO,CAAC,CAAA;QADI,YAAO,GAAP,OAAO,CAAsB;IAEjD,CAAC;IAED,OAAO,CAAQ,MAAc;QAC3B,OAAO,IAAI,CAAC,WAAW,CAAkB,GAAG,IAAI,CAAC,YAAY,IAAI,MAAM,EAAE,CAAC,CAAA;IAC5E,CAAC;IAED,OAAO,CAAC,OAA4C;QAClD,OAAO,IAAI,CAAC,WAAW,CACrB,IAAI,CAAC,YAAY;YACjB,CAAC,OAAO,CAAC,CAAC;gBACR,IAAI,MAAM,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,EAAE,KAAK,CAAC,EAAE,EAAE,CAAC,GAAG,GAAG,IAAI,KAAK,EAAE,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;gBAClF,EAAE,CAAC,CACN,CAAC;IACJ,CAAC;IAED,MAAM,CAAC,MAAc;QACnB,OAAO,IAAI,CAAC,OAAO,CAAC,GAAG,IAAI,CAAC,YAAY,IAAI,MAAM,EAAE,EAAE,EAAC,MAAM,EAAE,QAAQ,EAAC,CAAC,CAAC;IAC5E,CAAC;IAED,MAAM,CAAQ,MAAc,EAAE,OAAwC;QACpE,OAAO,IAAI,CAAC,WAAW,CACrB,GAAG,IAAI,CAAC,YAAY,IAAI,MAAM,EAAE,EAChC;YACE,MAAM,EAAE,KAAK;YACb,OAAO,EAAE,EAAC,cAAc,EAAE,kBAAkB,EAAC;YAC7C,IAAI,EAAE,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC;SAC9B,CACF,CAAA;IACH,CAAC;IAED,MAAM,CAAQ,IAAoE;QAChF,OAAO,IAAI,CAAC,WAAW,CAAe,IAAI,CAAC,YAAY,EAAE;YACvD,MAAM,EAAE,MAAM;YACd,OAAO,EAAE,EAAC,cAAc,EAAE,kBAAkB,EAAC;YAC7C,IAAI,EAAE,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC;SAC3B,CAAC,CAAA;IACJ,CAAC;IAED,gBAAgB,CAAQ,MAAc;QACpC,OAAO,IAAI,CAAC,WAAW,CAAkB,GAAG,IAAI,CAAC,YAAY,IAAI,MAAM,YAAY,CAAC,CAAA;IACtF,CAAC;IAED,KAAK,CAAC,gBAAgB,CAAQ,MAAc,EAAE,IAAO;QACnD,MAAM,GAAG,GAAG,MAAM,IAAI,CAAC,OAAO,CAAC,GAAG,IAAI,CAAC,YAAY,IAAI,MAAM,YAAY,EAAE;YACzE,MAAM,EAAE,MAAM;YACd,OAAO,EAAE,EAAC,cAAc,EAAE,kBAAkB,EAAC;YAC7C,IAAI,EAAE,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC;SAC3B,CAAC,CAAA;QACF,IAAI,GAAG,CAAC,MAAM,IAAI,GAAG,EAAE;YACrB,MAAM,IAAI,KAAK,CAAC,8BAA8B,CAAC,CAAA;SAChD;IACH,CAAC;CACF"}

package/package.json

@@ -0,0 +1,18 @@
+{
+  "name": "@qelos/sdk",
+  "version": "2.0.22",
+  "description": "SDK for Qelos API",
+  "main": "./dist/index.js",
+  "scripts": {
+    "build": "tsc"
+  },
+  "author": "David Meir-Levy <davidmeirlevy@gmail.com>",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "devDependencies": {
+    "typescript": "^4.6.3"
+  },
+  "gitHead": "c4a69b318689cb5c7d35a05f057e0ed6c9676594"
+}

package/src/administrator/drafts.ts

@@ -0,0 +1,57 @@
+import {QelosSDKOptions} from '../types';
+import BaseSDK from '../base-sdk';
+
+export interface IDraftMetadata {
+  contextDisplayName?: string;
+  contextRouteParams?: any;
+  contextType: string;
+  contextId?: string;
+  contextData: any;
+}
+
+export interface IDraft extends IDraftMetadata {
+  user: string;
+  tenant?: string;
+}
+
+export default class GpDrafts extends BaseSDK {
+  private relativePath = '/api/drafts';
+
+  constructor(options: QelosSDKOptions) {
+    super(options)
+  }
+
+  #getDraftUrl(contextType, contextId): string {
+    const url = new URL(this.relativePath, 'https://stub');
+    if (contextType) {
+      url.searchParams.append('contextType', contextType)
+    }
+    if (contextId) {
+      url.searchParams.append('contextId', contextId)
+    }
+    return url.href.replace(url.origin, '');
+  }
+
+  getList() {
+    return this.callJsonApi<IDraft[]>(this.relativePath);
+  }
+
+  getDraft(contextType: string, contextId: string) {
+    return this.callJsonApi<IDraft>(this.#getDraftUrl(contextType, contextId))
+  }
+
+  setDraft(draft: IDraftMetadata): Promise<IDraft> {
+    return this.callJsonApi<IDraft>(
+      this.relativePath,
+      {
+        method: 'put',
+        headers: {'content-type': 'application/json'},
+        body: JSON.stringify(draft)
+      }
+    )
+  }
+
+  remove(contextType: string, contextId: string): Promise<any> {
+    return this.callApi(this.#getDraftUrl(contextType, contextId), {method: 'delete'});
+  }
+}

package/src/administrator/events.ts

@@ -0,0 +1,40 @@
+import {QelosSDKOptions} from '../types';
+import BaseSDK from '../base-sdk';
+
+export interface IQelosEvent {
+  tenant: string;
+  user?: string;
+  source: string;
+  kind: string;
+  eventName: string;
+  description: string;
+  metadata?: any;
+  created: Date;
+}
+
+export default class QlEvents extends BaseSDK {
+  private relativePath = '/api/events';
+
+  constructor(options: QelosSDKOptions) {
+    super(options)
+  }
+
+  getList({page}: { page?: number } = {}) {
+    return this.callJsonApi<IQelosEvent[]>(this.relativePath + (page ? ('?page=' + page) : ''));
+  }
+
+  getEvent(eventId: string) {
+    return this.callJsonApi<IQelosEvent>(this.relativePath + '/' + eventId)
+  }
+
+  async dispatch(payload: Partial<IQelosEvent>): Promise<void> {
+    await this.callApi(
+      this.relativePath,
+      {
+        method: 'post',
+        headers: {'content-type': 'application/json'},
+        body: JSON.stringify(payload)
+      }
+    )
+  }
+}

package/src/administrator/index.ts

@@ -0,0 +1,21 @@
+import QelosSDK from '../index';
+import {QelosSDKOptions} from '../types';
+import GpUsers from './users';
+import GpManageLayouts from '../manage-layouts';
+import GpDrafts from './drafts';
+import QlEvents from './events';
+
+export default class QelosAdministratorSDK<T = any> extends QelosSDK {
+  users: GpUsers<T>;
+  manageLayouts: GpManageLayouts;
+  drafts: GpDrafts;
+  events: QlEvents;
+
+  constructor(options: QelosSDKOptions) {
+    super(options);
+    this.users = new GpUsers<T>(options);
+    this.manageLayouts = new GpManageLayouts(options);
+    this.drafts = new GpDrafts(options);
+    this.events = new QlEvents(options);
+  }
+}

package/src/administrator/layouts.ts

@@ -0,0 +1,56 @@
+import { QelosSDKOptions } from "../types";
+import BaseSDK from "../base-sdk";
+
+export enum LayoutKind {
+  INDEX = "index",
+  SEARCH = "search",
+  TAG = "tag",
+  CATEGORY = "category",
+  POST = "post",
+}
+
+export enum LayoutConnectedDataKind {
+  MENU = "menu",
+  BLOCK = "block",
+  HTTP = "http",
+  POSTS = "posts",
+  CATEGORY_POSTS = "categoryPosts",
+  CATEGORY = "category",
+  POST = "post",
+}
+
+export interface ILayoutContent {
+  component: string;
+  predefined: boolean;
+  classes: string;
+  children?: ILayoutContent[];
+  props: {
+    [key: string]: any;
+  };
+}
+
+export interface ILayout {
+  kind: LayoutKind;
+  connectedData: Array<{
+    kind: LayoutConnectedDataKind;
+    data?: any;
+    identifier: string;
+    reference: string;
+    context?: any;
+  }>;
+  content: ILayoutContent[];
+
+  [key: string]: any;
+}
+
+export default class GpLayouts extends BaseSDK {
+  private relativePath = "/api/layouts";
+
+  constructor(options: QelosSDKOptions) {
+    super(options);
+  }
+
+  getLayout(kind: LayoutKind, extra?: Partial<RequestInit>) {
+    return this.callJsonApi<ILayout>(`${this.relativePath}/${kind}`, extra);
+  }
+}

package/src/administrator/users.ts

@@ -0,0 +1,70 @@
+import {QelosSDKOptions} from '../types';
+import BaseSDK from '../base-sdk';
+import {IUser} from '../authentication';
+
+export interface IManagedUser<T = any> extends IUser {
+  internalMetadata?: T;
+}
+
+export interface IManagedUserRequest<T = any> extends IManagedUser<T> {
+  password?: string;
+}
+
+export default class GpUsers<T = any, E = any> extends BaseSDK {
+  private relativePath = '/api/users';
+
+  constructor(private options: QelosSDKOptions) {
+    super(options)
+  }
+
+  getUser<Z = T>(userId: string) {
+    return this.callJsonApi<IManagedUser<Z>>(`${this.relativePath}/${userId}`)
+  }
+
+  getList(filters?: { email: string, exact?: boolean }) {
+    return this.callJsonApi<IUser[]>(
+      this.relativePath +
+      (filters ?
+        `?${Object.entries(filters).map(([key, value]) => `${key}=${value}`).join('&')}` :
+        '')
+    );
+  }
+
+  remove(userId: string): Promise<any> {
+    return this.callApi(`${this.relativePath}/${userId}`, {method: 'delete'});
+  }
+
+  update<Z = T>(userId: string, changes: Partial<IManagedUserRequest<Z>>): Promise<IManagedUser> {
+    return this.callJsonApi<IManagedUser>(
+      `${this.relativePath}/${userId}`,
+      {
+        method: 'put',
+        headers: {'content-type': 'application/json'},
+        body: JSON.stringify(changes)
+      }
+    )
+  }
+
+  create<Z = T>(user: Omit<IManagedUserRequest<Z>, '_id' | 'fullName' | 'birthDate'>): Promise<IManagedUser<Z>> {
+    return this.callJsonApi<IManagedUser>(this.relativePath, {
+      method: 'post',
+      headers: {'content-type': 'application/json'},
+      body: JSON.stringify(user)
+    })
+  }
+
+  getEncryptedData<Z = E>(userId: string) {
+    return this.callJsonApi<IManagedUser<Z>>(`${this.relativePath}/${userId}/encrypted`)
+  }
+
+  async setEncryptedData<Z = E>(userId: string, data: Z): Promise<void> {
+    const res = await this.callApi(`${this.relativePath}/${userId}/encrypted`, {
+      method: 'post',
+      headers: {'content-type': 'application/json'},
+      body: JSON.stringify(data)
+    })
+    if (res.status >= 300) {
+      throw new Error('could not set encrypted data')
+    }
+  }
+}

package/src/authentication.ts

@@ -0,0 +1,139 @@
+import {QelosSDKOptions} from './types';
+import BaseSDK from './base-sdk';
+
+export interface IUser {
+  _id: string;
+  email: string;
+  fullName: string;
+  firstName: string;
+  lastName: string;
+  birthDate: string;
+  roles: string[];
+
+  [key: string]: any;
+}
+
+export interface ICredentials {
+  email: string;
+  password: string;
+  roles?: string[];
+}
+
+export interface BasicPayload {
+  user: IUser;
+}
+
+export interface ISignupInformation {
+  email: string;
+  password: string;
+  fullName?: string;
+  firstName: string;
+  lastName: string;
+  birthDate: string;
+}
+
+export default class GpAuthentication extends BaseSDK {
+
+  #refreshToken: string;
+  #accessToken: string;
+
+  get accessToken() {
+    return this.#accessToken;
+  }
+
+  constructor(options: QelosSDKOptions) {
+    super(options);
+    if (options.accessToken || options.getAccessToken) {
+      this.#accessToken = options.accessToken || options.getAccessToken();
+      delete options.accessToken;
+    }
+    if (options.refreshToken) {
+      this.#refreshToken = options.refreshToken;
+      delete options.refreshToken;
+    }
+  }
+
+  signin(credentials: ICredentials) {
+    return this.callJsonApi<{ payload: BasicPayload }>('/api/signin', {
+      method: 'post',
+      headers: {'content-type': 'application/json'},
+      body: JSON.stringify(credentials)
+    })
+  }
+
+  oAuthSignin(credentials: ICredentials) {
+    return this.callJsonApi<{ payload: BasicPayload & { token: string, refreshToken: string } }>(
+      '/api/signin',
+      {
+        method: 'post',
+        headers: {'content-type': 'application/json'},
+        body: JSON.stringify({...credentials, authType: 'oauth'})
+      })
+      .then(data => {
+        this.#accessToken = data.payload.token;
+        this.#refreshToken = data.payload.refreshToken;
+        return data;
+      })
+  }
+
+  signup(information: ISignupInformation) {
+    return this.callJsonApi<{ payload: BasicPayload }>(
+      '/api/signup',
+      {
+        method: 'post',
+        headers: {'content-type': 'application/json'},
+        body: JSON.stringify(information)
+      })
+  }
+
+  oAuthSignup(information: ISignupInformation) {
+    return this.callJsonApi<{ payload: BasicPayload & { token: string, refreshToken: string } }>(
+      '/api/signup',
+      {
+        method: 'post',
+        headers: {'content-type': 'application/json'},
+        body: JSON.stringify({...information, authType: 'oauth'})
+      })
+      .then(data => {
+        this.#accessToken = data.payload.token;
+        this.#refreshToken = data.payload.refreshToken;
+        return data;
+      })
+  }
+
+  refreshToken(refreshToken?: string) {
+    refreshToken = refreshToken || this.#refreshToken;
+    if (!refreshToken) {
+      throw new Error('existing refresh token not found');
+    }
+    return this.callJsonApi<{ payload: BasicPayload & { token: string, refreshToken: string } }>(
+      '/api/token/refresh',
+      {
+        method: 'post',
+        headers: {
+          Authorization: 'Bearer ' + refreshToken
+        }
+      })
+      .then(data => {
+        this.#accessToken = data.payload.token;
+        this.#refreshToken = data.payload.refreshToken;
+        return data;
+      })
+  }
+
+  logout() {
+    return this.callApi('/api/logout', {method: 'post'})
+  }
+
+  getLoggedInUser() {
+    return this.callJsonApi<IUser>('/api/me')
+  }
+
+  updateLoggedInUser(changes: Partial<IUser & { password?: string }>): Promise<IUser> {
+    return this.callJsonApi<IUser>('/api/me', {
+      method: 'post',
+      headers: {'content-type': 'application/json'},
+      body: JSON.stringify(changes)
+    })
+  }
+}

package/src/base-sdk.ts

@@ -0,0 +1,28 @@
+import {FetchLike, QelosSDKOptions} from './types';
+
+export default class BaseSDK {
+  #appUrl: string;
+  #fetch: FetchLike;
+
+  constructor(private qlOptions: QelosSDKOptions) {
+    this.#appUrl = qlOptions.appUrl.endsWith('/') ? qlOptions.appUrl.slice(0, -1) : qlOptions.appUrl;
+    this.#fetch = qlOptions.fetch;
+  }
+
+  callApi(relativeUrl: string, data?: RequestInit) {
+    data = data || {};
+    data.headers = data.headers || {};
+    Object.assign(data.headers, this.qlOptions.extraHeaders());
+    return this.#fetch(this.#appUrl + relativeUrl, data);
+  }
+
+  callJsonApi<T>(relativeUrl: string, data?: RequestInit): Promise<T> {
+    return this.callApi(relativeUrl, data).then(async res => {
+      const body = await res.json()
+      if (res.status >= 300) {
+        throw body;
+      }
+      return body;
+    });
+  }
+}

package/src/blocks.ts

@@ -0,0 +1,49 @@
+import {QelosSDKOptions} from './types';
+import BaseSDK from './base-sdk';
+
+export interface IBlock {
+  name: string;
+  description?: string;
+  content: string;
+  contentType?: 'content' | 'html'
+
+  [key: string]: any;
+}
+
+export default class GpBlocks extends BaseSDK {
+  private relativePath = '/api/blocks';
+
+  constructor(options: QelosSDKOptions) {
+    super(options)
+  }
+
+  getBlock(blockId: string) {
+    return this.callJsonApi<IBlock>(`${this.relativePath}/${blockId}`)
+  }
+
+  getList() {
+    return this.callJsonApi<IBlock[]>(this.relativePath);
+  }
+
+  remove(blockId: string): Promise<any> {
+    return this.callApi(`${this.relativePath}/${blockId}`, {method: 'delete'});
+  }
+
+  update(blockId: string, changes: Partial<IBlock>): Promise<IBlock> {
+    return this.callJsonApi<IBlock>(
+      `${this.relativePath}/${blockId}`,
+      {
+        method: 'put',
+        headers: {'content-type': 'application/json'},
+        body: JSON.stringify(changes)}
+    )
+  }
+
+  create(block: IBlock): Promise<IBlock> {
+    return this.callJsonApi<IBlock>(this.relativePath, {
+      method: 'post',
+      headers: {'content-type': 'application/json'},
+      body: JSON.stringify(block)
+    })
+  }
+}

package/src/categories.ts

@@ -0,0 +1,62 @@
+import { QelosSDKOptions } from "./types";
+import BaseSDK from "./base-sdk";
+
+export interface ICategory {
+  _id?: string;
+  created: Date;
+  isPublic: boolean;
+  name: string;
+  path: string;
+  content?: string;
+  [key: string]: any;
+}
+
+export default class GpCategories extends BaseSDK {
+  private relativePath = "/api/categories";
+
+  constructor(options: QelosSDKOptions) {
+    super(options);
+  }
+
+  getByPath(path: string, extra?: Partial<RequestInit>) {
+    return this.callJsonApi<ICategory>(
+      `${this.relativePath}/${encodeURI(path)}`,
+      extra
+    );
+  }
+
+  getList(
+    options: { target: "front" | "admin" },
+    extra?: Partial<RequestInit>
+  ) {
+    const queryParams = new URLSearchParams(options);
+    return this.callJsonApi<ICategory[]>(
+      `${this.relativePath}?${queryParams}`,
+      extra
+    );
+  }
+
+  remove(path: string): Promise<Response> {
+    return this.callApi(`${this.relativePath}/${encodeURI(path)}`, {
+      method: "delete",
+    });
+  }
+
+  update(path: string, changes: Partial<ICategory>): Promise<ICategory> {
+    return this.callJsonApi<ICategory>(
+      `${this.relativePath}/${encodeURI(path)}`, {
+        method: "put",
+        headers: {'content-type': 'application/json'},
+        body: JSON.stringify(changes)
+      }
+    );
+  }
+
+  create(category: ICategory): Promise<ICategory> {
+    return this.callJsonApi<ICategory>(this.relativePath, {
+      method: "post",
+      headers: {'content-type': 'application/json'},
+      body: JSON.stringify(category),
+    });
+  }
+}

package/src/configurations.ts

@@ -0,0 +1,40 @@
+import { QelosSDKOptions } from "./types";
+import BaseSDK from "./base-sdk";
+
+export interface IAppConfiguration {
+  name: string;
+  logoUrl: string;
+  description: string;
+  keywords: string;
+  slogan: string;
+  language: string;
+  direction: string;
+  titleSuffix: string;
+  themeStylesUrl: string;
+  homeScreen: string;
+  colorsPalette: Record<string, string>;
+  websiteUrls: string[];
+
+  [key: string]: any;
+}
+
+export default class GpConfigurations extends BaseSDK {
+  private relativePath = "/api/configurations/app-configuration";
+
+  constructor(options: QelosSDKOptions) {
+    super(options);
+  }
+
+  getAppConfiguration(extra?: Partial<RequestInit>) {
+    return this.callJsonApi<IAppConfiguration>(this.relativePath, extra);
+  }
+
+  update(changes: Partial<IAppConfiguration>, extra?: Partial<RequestInit>): Promise<IAppConfiguration> {
+    return this.callJsonApi<IAppConfiguration>(this.relativePath, {
+      method: "put",
+      headers: {'content-type': 'application/json'},
+      body: JSON.stringify(changes),
+      ...(extra || {}),
+    });
+  }
+}

package/src/index.ts

@@ -0,0 +1,45 @@
+import {QelosSDKOptions} from './types';
+import BaseSDK from './base-sdk';
+import GpCategories from './categories';
+import GpPosts from './posts';
+import GpMenus from './menus';
+import GpConfigurations from './configurations';
+import GpAuthentication from './authentication';
+import GpBlocks from './blocks';
+import GpLayouts from './administrator/layouts';
+
+export default class QelosSDK extends BaseSDK {
+
+  categories: GpCategories;
+  posts: GpPosts;
+  menus: GpMenus;
+  blocks: GpBlocks;
+  layouts: GpLayouts;
+  configurations: GpConfigurations;
+  authentication: GpAuthentication;
+
+  constructor(private options: QelosSDKOptions) {
+    super(options);
+    this.categories = new GpCategories(this.options);
+    this.posts = new GpPosts(this.options);
+    this.menus = new GpMenus(this.options);
+    this.blocks = new GpBlocks(this.options);
+    this.layouts = new GpLayouts(this.options);
+    this.configurations = new GpConfigurations(this.options);
+    this.authentication = new GpAuthentication(this.options);
+
+    if (!options.getAccessToken) {
+      options.getAccessToken = () => this.authentication.accessToken;
+    }
+    if (!options.extraHeaders) {
+      options.extraHeaders = () => {
+        const token = options.getAccessToken();
+        if (token) {
+          return {authorization: 'Bearer ' + token}
+        }
+        return {}
+      }
+    }
+  }
+
+}