@content-island/vscode-api-client 0.1.0

package/README.md

@@ -0,0 +1,58 @@
+# @content-island/vscode-api-client
+
+## Installation
+
+```bash
+npm install @content-island/vscode-api-client
+```
+
+## Examples
+
+### Basic Usage
+
+_./src/client.ts_
+
+```ts
+import { createClient } from '@content-island/vscode-api-client';
+
+export const client = createClient();
+```
+
+_./src/index.ts_
+
+```ts
+import { client } from './client';
+import * as vscode from 'vscode';
+
+export async function activate(context: vscode.ExtensionContext) {
+  client.setContext(context);
+
+  const uriHandler = vscode.window.registerUriHandler({
+    handleUri: async (uri: vscode.Uri) => {
+      const params = new URLSearchParams(uri.query);
+      const authorizationCode = params.get('authorizationCode');
+      const userId = params.get('userId');
+
+      await client.authorize(authorizationCode, userId);
+    },
+  });
+}
+```
+
+_./src/commands/pull-content.ts_
+
+```ts
+import { client } from '../client';
+import * as vscode from 'vscode';
+
+export const pullContent = async () => {
+  const project = await client.getProject();
+  if (!project) {
+    vscode.window.showErrorMessage('No project found. Please link your project first.');
+    return;
+  }
+
+  // Logic to pull content from the project
+  vscode.window.showInformationMessage(`Content pulled for project: ${project.name}`);
+};
+```

package/dist/index.d.ts

@@ -0,0 +1,324 @@
+import * as vscode from 'vscode';
+
+declare type AllowedModelFields<M extends Model, ValueType> = Partial<Omit<{
+    [K in keyof M as M[K] extends string | number | boolean ? `fields.${string & K}` : never]?: ValueType;
+}, 'fields.id' | 'fields.language'>>;
+
+declare interface ApiClient {
+    getProject: () => Promise<Project>;
+    getContentList: <M extends Model = Model & Record<string, any>>(queryParam?: ContentListQueryParams<M>) => Promise<M[]>;
+    getContent: <M extends Model = Model & Record<string, any>>(queryParam: ContentQueryParams<M>) => Promise<M>;
+    getRawContentList: <M extends Model = Model & Record<string, any>>(queryParam?: ContentListQueryParams<M>) => Promise<Content[]>;
+    getRawContent: <M extends Model = Model & Record<string, any>>(queryParam: ContentQueryParams<M>) => Promise<Content>;
+    getContentListSize: <M extends Model = Model & Record<string, any>>(queryParam?: ContentListSizeQueryParams<M>) => Promise<number>;
+    updateContentFieldValue: (contentId: string, fieldId: string, value: any) => Promise<boolean>;
+}
+
+export declare type ClientFilter<Type = string | boolean> = Type | {
+    in?: Type[];
+};
+
+export declare interface Content {
+    id: string;
+    name: string;
+    contentType: Lookup;
+    lastUpdate: string;
+    fields: Field[];
+}
+
+export declare type ContentListQueryParams<M extends Model = Model & Record<string, any>> = QueryParams<M>;
+
+export declare type ContentListSizeQueryParams<M extends Model = Model & Record<string, any>> = Omit<QueryParams<M>, 'sort' | 'pagination' | 'includeRelatedContent'>;
+
+export declare type ContentQueryParams<M extends Model = Model & Record<string, any>> = Omit<QueryParams<M>, 'sort' | 'pagination'>;
+
+declare interface ContentType extends Lookup {
+    fields: ContentTypeField[];
+}
+
+declare interface ContentTypeField extends Lookup {
+    type: FieldType;
+    tsType: string;
+    isArray: boolean;
+    isRequired?: boolean;
+}
+
+export declare const createClient: (options?: VSCodeClientOptions) => VSCodeApiClient;
+
+export declare interface Field {
+    id: string;
+    name: string;
+    value: any;
+    type: FieldType;
+    isArray: boolean;
+    language: string;
+}
+
+declare type FieldEntityType = `${string}|${string}`;
+
+export declare type FieldType =
+| 'short-text'
+| 'long-text'
+| 'number'
+| 'date'
+| 'date-time'
+| 'media'
+| 'boolean'
+| 'color'
+| FieldEntityType;
+
+declare type FilterableFields<M extends Model = Model> = {
+    id?: ClientFilter;
+    lastUpdate?: ClientFilter;
+    language?: ClientFilter<M['language'] extends undefined ? string : M['language']>;
+    contentType?: ClientFilter;
+    includeRelatedContent?: boolean;
+} & AllowedModelFields<M, ClientFilter>;
+
+export declare type LanguageCode =
+| 'aa'
+| 'ab'
+| 'ae'
+| 'af'
+| 'ak'
+| 'am'
+| 'an'
+| 'ar'
+| 'as'
+| 'av'
+| 'ay'
+| 'az'
+| 'ba'
+| 'be'
+| 'bg'
+| 'bh'
+| 'bi'
+| 'bm'
+| 'bn'
+| 'bo'
+| 'br'
+| 'bs'
+| 'ca'
+| 'ce'
+| 'ch'
+| 'co'
+| 'cr'
+| 'cs'
+| 'cu'
+| 'cv'
+| 'cy'
+| 'da'
+| 'de'
+| 'dv'
+| 'dz'
+| 'ee'
+| 'el'
+| 'en'
+| 'eo'
+| 'es'
+| 'et'
+| 'eu'
+| 'fa'
+| 'ff'
+| 'fi'
+| 'fj'
+| 'fo'
+| 'fr'
+| 'fy'
+| 'ga'
+| 'gd'
+| 'gl'
+| 'gn'
+| 'gu'
+| 'gv'
+| 'ha'
+| 'he'
+| 'hi'
+| 'ho'
+| 'hr'
+| 'ht'
+| 'hu'
+| 'hy'
+| 'hz'
+| 'ia'
+| 'id'
+| 'ie'
+| 'ig'
+| 'ii'
+| 'ik'
+| 'io'
+| 'is'
+| 'it'
+| 'iu'
+| 'ja'
+| 'jv'
+| 'ka'
+| 'kg'
+| 'ki'
+| 'kj'
+| 'kk'
+| 'kl'
+| 'km'
+| 'kn'
+| 'ko'
+| 'kr'
+| 'ks'
+| 'ku'
+| 'kv'
+| 'kw'
+| 'ky'
+| 'la'
+| 'lb'
+| 'lg'
+| 'li'
+| 'ln'
+| 'lo'
+| 'lt'
+| 'lu'
+| 'lv'
+| 'mg'
+| 'mh'
+| 'mi'
+| 'mk'
+| 'ml'
+| 'mn'
+| 'mr'
+| 'ms'
+| 'mt'
+| 'my'
+| 'na'
+| 'nb'
+| 'nd'
+| 'ne'
+| 'ng'
+| 'nl'
+| 'nn'
+| 'no'
+| 'nr'
+| 'nv'
+| 'ny'
+| 'oc'
+| 'oj'
+| 'om'
+| 'or'
+| 'os'
+| 'pa'
+| 'pi'
+| 'pl'
+| 'ps'
+| 'pt'
+| 'qu'
+| 'rm'
+| 'rn'
+| 'ro'
+| 'ru'
+| 'rw'
+| 'sa'
+| 'sc'
+| 'sd'
+| 'se'
+| 'sg'
+| 'si'
+| 'sk'
+| 'sl'
+| 'sm'
+| 'sn'
+| 'so'
+| 'sq'
+| 'sr'
+| 'ss'
+| 'st'
+| 'su'
+| 'sv'
+| 'sw'
+| 'ta'
+| 'te'
+| 'tg'
+| 'th'
+| 'ti'
+| 'tk'
+| 'tl'
+| 'tn'
+| 'to'
+| 'tr'
+| 'ts'
+| 'tt'
+| 'tw'
+| 'ty'
+| 'ug'
+| 'uk'
+| 'ur'
+| 'uz'
+| 've'
+| 'vi'
+| 'vo'
+| 'wa'
+| 'wo'
+| 'xh'
+| 'yi'
+| 'yo'
+| 'za'
+| 'zh'
+| 'zu';
+
+export declare interface Lookup<ID = string> {
+    id: ID;
+    name: string;
+}
+
+export declare const mapContentToModel: <M extends Model<Language> = Model<any> & Record<string, any>, Language = M["language"]>(content: Content, language?: Language) => M;
+
+export declare interface Media {
+    name: string;
+    url: string;
+}
+
+export declare type Model<Language = string> = {
+    id: string;
+    language?: Language;
+    lastUpdate?: string;
+};
+
+declare interface Options {
+    accessToken: string;
+    domain?: string;
+    secureProtocol?: boolean;
+    apiVersion?: string;
+    metadata?: string;
+}
+
+declare type Pagination = {
+    take?: number;
+    skip?: number;
+};
+
+export declare interface Project {
+    id: string;
+    name: string;
+    languages: LanguageCode[];
+    contentTypes?: ContentType[];
+}
+
+declare type QueryParams<M extends Model = Model & Record<string, any>> = FilterableFields<M> & {
+    sort?: SortableFields<M>;
+    pagination?: Pagination;
+};
+
+declare type SortableFields<M extends Model> = {
+    contentType?: SortOrder;
+    lastUpdate?: SortOrder;
+} & AllowedModelFields<M, SortOrder>;
+
+declare type SortOrder = 'asc' | 'desc';
+
+export declare interface VSCodeApiClient extends ApiClient {
+    setVSCodeExtensionContext: (context: vscode.ExtensionContext) => void;
+    authorize: (authorizationCode: string, metadata: string) => Promise<void>;
+    authorizeByProjectId: (projectId: string) => Promise<void>;
+}
+
+export declare type VSCodeClientOptions = Omit<Options, 'accessToken'> & {
+    loginDomain?: string;
+};
+
+export { }

package/dist/index.js

@@ -0,0 +1,155 @@
+import { createClient as I } from "@content-island/api-client";
+import { mapContentToModel as Y } from "@content-island/api-client";
+import * as a from "vscode";
+import _ from "node:crypto";
+import A from "node:util";
+let E;
+const P = () => {
+  if (!E)
+    throw new Error("Extension context has not been set.");
+  return E;
+}, S = (t) => {
+  E = t;
+};
+let l = {
+  getContext: P,
+  setContext: S
+};
+const g = {
+  IS_PRODUCTION: !0,
+  DEFAULT_API_CLIENT_DOMAIN: "api.contentisland.net",
+  DEFAULT_API_CLIENT_VERSION: "1.0",
+  DEFAULT_LOGIN_DOMAIN: "app.contentisland.net"
+}, d = "content-island-vscode", u = {
+  SALT: `${d}.salt`,
+  ACCESS_TOKEN_BY_PROJECT_ID: (t) => `${d}.access-token.${t}`,
+  METADATA_BY_PROJECT_ID: (t) => `${d}.metadata.${t}`
+}, h = {
+  get: async (t) => await l.getContext().secrets.get(u.METADATA_BY_PROJECT_ID(t)),
+  set: async (t, o) => {
+    await l.getContext().secrets.store(u.METADATA_BY_PROJECT_ID(t), o);
+  }
+}, C = {
+  get: async (t) => await l.getContext().secrets.get(u.ACCESS_TOKEN_BY_PROJECT_ID(t)),
+  set: async (t, o) => {
+    await l.getContext().secrets.store(u.ACCESS_TOKEN_BY_PROJECT_ID(t), o);
+  }
+}, L = (t) => {
+  const s = (t.secureProtocol === void 0 ? g.IS_PRODUCTION : t.secureProtocol) ? "https" : "http", e = t.domain ? t.domain : g.DEFAULT_API_CLIENT_DOMAIN, n = t.apiVersion ? t.apiVersion : g.DEFAULT_API_CLIENT_VERSION;
+  return `${s}://${e}/api/${n}`;
+}, y = (t) => {
+  const s = (t.secureProtocol === void 0 ? g.IS_PRODUCTION : t.secureProtocol) ? "https" : "http", e = t.loginDomain ? t.loginDomain : g.DEFAULT_LOGIN_DOMAIN;
+  return `${s}://${e}/#/?redirect=vscode`;
+}, f = 16, p = (t = f) => _.randomBytes(t).toString("hex"), O = 64, m = "sha512", x = 1e5, D = async (t, o, s = O) => (await A.promisify(_.pbkdf2)(t, o, x, s, m)).toString("hex"), N = async () => {
+  const t = l.getContext();
+  let o = await t.secrets.get(u.SALT);
+  return o || (o = p(32), await t.secrets.store(u.SALT, o)), o;
+}, k = 32, R = async (t) => {
+  const o = await N();
+  return await D(t, o, k);
+}, w = async (t) => {
+  const o = "Open Login Page";
+  if (await a.window.showInformationMessage(
+    "You need to log in to Content Island to continue. Do you want to open the login page?",
+    o
+  ) !== o)
+    return;
+  const e = a.Uri.parse(y(t));
+  await a.env.openExternal(e);
+}, M = (t) => {
+  try {
+    return JSON.parse(t.message);
+  } catch {
+    return null;
+  }
+}, i = (t, o) => async (...s) => {
+  try {
+    return await t(...s);
+  } catch (e) {
+    const n = M(e);
+    if (n) {
+      if (n.status === 401)
+        throw await w(o), new Error("Unauthorized: Please log in to continue.");
+      n.status === 403 && a.window.showErrorMessage("Access forbidden: You do not have permission to perform this action.");
+    }
+    throw e;
+  }
+}, U = async (t, o, s) => {
+  const e = L(t);
+  let n;
+  const c = {
+    authorizationCode: o,
+    metadata: s
+  };
+  try {
+    n = await fetch(`${e}/security/vscode/token`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(c)
+    });
+  } catch {
+    a.window.showErrorMessage(
+      "Unable to connect to the authorization server. Check your network connection and try again."
+    );
+  }
+  n.ok || (n.status === 401 ? await w(t) : n.status === 403 && a.window.showErrorMessage(
+    "You do not have permission to access this resource. Please check your access rights in Content Island."
+  ), a.window.showErrorMessage(
+    "Failed to obtain access token. Please complete the authorization in Content Island."
+  ));
+  try {
+    const r = await n.json();
+    return (!r?.accessToken || typeof r.accessToken != "string") && (a.window.showErrorMessage("Invalid response from the authorization server."), await w(t)), r.accessToken;
+  } catch {
+    a.window.showErrorMessage("Error processing response from the authorization server.");
+  }
+}, T = (t) => {
+  const o = `PREVIEW_${t.accessToken}`, s = I({ ...t, accessToken: o });
+  return {
+    ...s,
+    getProject: async () => {
+      const e = await s.getProject();
+      return {
+        ...e,
+        id: await R(e.id)
+      };
+    }
+  };
+}, B = (t = {}) => {
+  let o = T({ ...t, accessToken: "" });
+  const s = (e, n) => {
+    o = T({ ...t, accessToken: e, metadata: n });
+  };
+  return {
+    authorize: async (e, n) => {
+      const c = await U(t, e, n);
+      s(c, n);
+      const r = await o.getProject();
+      await C.set(r.id, c), await h.set(r.id, n);
+    },
+    authorizeByProjectId: async (e) => {
+      const n = await C.get(e), c = await h.get(e);
+      if (!n || !c) {
+        await w(t);
+        return;
+      }
+      s(n, c);
+    },
+    setVSCodeExtensionContext: (e) => {
+      l.setContext(e);
+    },
+    getProject: (...e) => i(() => o.getProject(...e), t)(),
+    getContentList: (...e) => i(() => o.getContentList(...e), t)(),
+    getContent: (...e) => i(() => o.getContent(...e), t)(),
+    getRawContentList: (...e) => i(() => o.getRawContentList(...e), t)(),
+    getRawContent: (...e) => i(() => o.getRawContent(...e), t)(),
+    getContentListSize: (...e) => i(() => o.getContentListSize(...e), t)(),
+    updateContentFieldValue: (...e) => i(() => o.updateContentFieldValue(...e), t)()
+  };
+};
+export {
+  B as createClient,
+  Y as mapContentToModel
+};

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "@content-island/vscode-api-client",
+  "version": "0.1.0",
+  "description": "Content Island - VSCode Extension API Client",
+  "private": false,
+  "sideEffects": false,
+  "author": "Lemoncode",
+  "license": "MIT",
+  "files": [
+    "dist"
+  ],
+  "type": "module",
+  "module": "./dist/index.js",
+  "main": "./dist/index.umd.cjs",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.umd.cjs"
+    }
+  },
+  "imports": {
+    "#*": "./src/*"
+  },
+  "scripts": {
+    "prebuild:dev": "sh ./create-dev-env.sh",
+    "build:dev": "vite build --mode development",
+    "build": "vite build",
+    "type-check": "tsc --noEmit --preserveWatchOutput",
+    "test": "vitest run -c ./config/test/config.ts",
+    "test:watch": "vitest -c ./config/test/config.ts"
+  },
+  "dependencies": {
+    "@content-island/api-client": "0.14.0"
+  },
+  "devDependencies": {
+    "@content-island/common-backend": "*",
+    "@types/vscode": "^1.105.0"
+  }
+}