@prisme.ai/sdk 0.0.2 → 1.0.1

package/Readme.md

@@ -16,7 +16,9 @@ You can set a different host by instantiating the Api class:
 
 ```
 import { Api } from '@prisme.ai/sdk';
-const api = new Api('https://my.custom.host')
+const api = new Api({
+  host: 'https://my.custom.host'
+})
 ```
 
 You are able to call un authentified methods like signin or signup, but you'll need a valid token to call the other. Just set its property:

package/dist/lib/api.d.ts

@@ -1,59 +1,140 @@
-import Fetcher from './fetcher';
+import Fetcher, { Fetched } from './fetcher';
 import { Event, Workspace } from './types';
 import { Events } from './events';
-declare type UserPermissions = Prismeai.UserPermissions;
+import WorkspacesEndpoint from './endpoints/workspaces';
+import UsersEndpoint from './endpoints/users';
+export type UserPermissions = {
+    permissions: Prismeai.UserPermissions['permissions'];
+    target: {
+        id?: string;
+        email?: string;
+        public?: boolean;
+        role?: string;
+        displayName?: string;
+    };
+};
+export interface ApiOptions {
+    host: string;
+    oidc?: {
+        url: string;
+        clientId: string;
+        clientIdHeader?: string;
+        redirectUri: string;
+    };
+}
+export interface AccessToken {
+    access_token: string;
+    id_token: string;
+    scope: string;
+    expiresIn: number;
+    token_type: 'Bearer';
+}
+export interface InteractiveSignin {
+    interaction: string;
+    login: string;
+    password: string;
+    remember?: boolean;
+}
 export declare class Api extends Fetcher {
+    opts: Required<ApiOptions>;
+    private sessionId?;
+    private _user?;
+    constructor(opts: ApiOptions);
+    get user(): (Prismeai.User & {
+        sessionId?: string | undefined;
+    }) | undefined;
     me(): Promise<any>;
-    signin(email: string, password: string): Promise<Prismeai.User & {
+    clientId(): string;
+    getAuthorizationURL(overrideRedirectUri?: string, authParams?: {
+        max_age?: string;
+        acr_values?: string;
+    }, locale?: string | undefined): Promise<{
+        url: string;
+        codeVerifier: string;
+        clientId: string;
+    }>;
+    signin(body: InteractiveSignin): Promise<{
+        redirectTo: string;
+    }>;
+    getToken(authorizationCode: string, codeVerifier: string, overrideRedirectUri?: string): Promise<AccessToken>;
+    createAnonymousSession(): Promise<Prismeai.User & {
         token: string;
     }>;
-    signup(email: string, password: string, firstName: string, lastName: string): Promise<Prismeai.User & {
+    signup(email: string, password: string, firstName: string, lastName: string, language: string): Promise<Prismeai.User & {
         token: string;
     }>;
-    signout(): Promise<void>;
+    getSignoutURL(redirectUri?: string): string;
+    sendValidationMail(email: string, language: string): Promise<unknown>;
+    validateMail(token: string): Promise<unknown>;
+    sendPasswordResetMail(email: string, language: string): Promise<unknown>;
+    passwordReset(token: string, password: string): Promise<unknown>;
     getWorkspaces(): Promise<Workspace[]>;
-    getWorkspace(id: string): Promise<Workspace | null>;
+    getWorkspace(id: string): Promise<PrismeaiAPI.GetWorkspace.Responses.$200>;
+    getWorkspaceSecurity(id: string): Promise<PrismeaiAPI.GetSecurity.Responses.$200>;
+    updateWorkspaceSecurity(workspaceId: string, security: Prismeai.WorkspaceSecurity): Promise<Fetched<PrismeaiAPI.UpdateSecurity.Responses.$200>>;
+    getWorkspaceRoles(id: string): Promise<Fetched<PrismeaiAPI.GetRoles.Responses.$200>>;
     createWorkspace(name: string): Promise<Workspace>;
-    updateWorkspace(workspace: Workspace): Promise<Workspace>;
+    duplicateWorkspace({ id }: {
+        id: string;
+    }): Promise<Workspace | null>;
+    updateWorkspace(workspace: Prismeai.DSULPatch): Promise<Fetched<PrismeaiAPI.UpdateWorkspace.Responses.$200> | null>;
     deleteWorkspace(workspaceId: Workspace['id']): Promise<Workspace>;
-    createAutomation(workspace: Workspace, automation: Prismeai.Automation): Promise<Prismeai.Automation & {
+    generateApiKey(workspaceId: Workspace['id'], events: string[], uploads?: string[]): Promise<string>;
+    updateApiKey(workspaceId: Workspace['id'], apiKey: string, events: string[], uploads?: string[]): Promise<string>;
+    getAutomation(workspaceId: string, automationSlug: string): Promise<Fetched<PrismeaiAPI.GetAutomation.Responses.$200>>;
+    createAutomation(workspaceId: Workspace['id'], automation: Prismeai.Automation): Promise<Fetched<Prismeai.Automation & {
         slug: string;
-    }>;
-    updateAutomation(workspace: Workspace, slug: string, automation: Prismeai.Automation): Promise<Prismeai.Automation & {
+    }>>;
+    updateAutomation(workspaceId: string, slug: string, automation: Prismeai.Automation): Promise<Fetched<Prismeai.Automation & {
         slug: string;
-    }>;
-    deleteAutomation(workspace: Workspace, slug: string): Promise<string>;
+    }>>;
+    deleteAutomation(workspaceId: string, slug: string): Promise<string>;
     getPages(workspaceId: NonNullable<Workspace['id']>): Promise<Prismeai.Page[]>;
-    getPage(workspaceId: PrismeaiAPI.GetPage.Parameters.WorkspaceId, pageId: PrismeaiAPI.GetPage.Parameters.Id): Promise<Prismeai.DetailedPage>;
-    getPageBySlug(pageSlug: PrismeaiAPI.GetPageBySlug.Parameters.Slug): Promise<Prismeai.DetailedPage>;
-    createPage(workspaceId: NonNullable<Workspace['id']>, page: Prismeai.Page): Promise<Prismeai.Page>;
-    updatePage(workspaceId: NonNullable<Workspace['id']>, page: Prismeai.Page): Promise<Prismeai.Page>;
-    deletePage(workspaceId: NonNullable<Workspace['id']>, pageId: string): Promise<Pick<Prismeai.Page, 'id'>>;
-    streamEvents(workspaceId: string): Promise<Events>;
-    getEvents(workspaceId: string, options?: {
-        beforeDate?: Date | string;
-    }): Promise<Event<Date>[]>;
+    getPage(workspaceId: PrismeaiAPI.GetPage.Parameters.WorkspaceId, pageSlug: PrismeaiAPI.GetPage.Parameters.Slug): Promise<Fetched<Prismeai.DetailedPage>>;
+    getPageBySlug(workspaceSlug: PrismeaiAPI.GetPageBySlug.Parameters.WorkspaceSlug, pageSlug: PrismeaiAPI.GetPageBySlug.Parameters.PageSlug): Promise<Fetched<Prismeai.DetailedPage>>;
+    createPage(workspaceId: PrismeaiAPI.CreatePage.Parameters.WorkspaceId, page: PrismeaiAPI.CreatePage.RequestBody): Promise<Prismeai.Page>;
+    updatePage(workspaceId: PrismeaiAPI.UpdatePage.Parameters.WorkspaceId, page: PrismeaiAPI.UpdatePage.RequestBody, prevSlug?: PrismeaiAPI.DeletePage.Parameters.Slug): Promise<Prismeai.Page>;
+    deletePage(workspaceId: PrismeaiAPI.DeletePage.Parameters.WorkspaceId, pageSlug: PrismeaiAPI.DeletePage.Parameters.Slug): Promise<Fetched<PrismeaiAPI.DeletePage.Responses.$200>>;
+    streamEvents(workspaceId: string, filters?: Record<string, any>): Promise<Events>;
+    getEvents(workspaceId: string, options?: Record<string, any>): Promise<Event<Date>[]>;
     postEvents(workspaceId: PrismeaiAPI.SendWorkspaceEvent.Parameters.WorkspaceId, events: PrismeaiAPI.SendWorkspaceEvent.RequestBody['events']): Promise<boolean>;
-    getPermissions(subjectType: PrismeaiAPI.GetPermissions.Parameters.SubjectType, subjectId: string): Promise<PrismeaiAPI.GetPermissions.Responses.$200>;
-    addPermissions(subjectType: PrismeaiAPI.GetPermissions.Parameters.SubjectType, subjectId: string, permissions: UserPermissions): Promise<PrismeaiAPI.Share.Responses.$200>;
-    deletePermissions(subjectType: PrismeaiAPI.GetPermissions.Parameters.SubjectType, subjectId: string, userEmail: string): Promise<PrismeaiAPI.RevokePermissions.Responses.$200>;
+    findContacts(query: PrismeaiAPI.FindContacts.RequestBody): Promise<PrismeaiAPI.FindContacts.Responses.$200>;
+    getPermissions(subjectType: PrismeaiAPI.GetPermissions.Parameters.SubjectType, subjectId: string): Promise<{
+        result: UserPermissions[];
+    }>;
+    addPermissions(subjectType: PrismeaiAPI.GetPermissions.Parameters.SubjectType, subjectId: string, permissions: UserPermissions): Promise<UserPermissions>;
+    deletePermissions(subjectType: PrismeaiAPI.GetPermissions.Parameters.SubjectType, subjectId: string, id: string): Promise<Fetched<PrismeaiAPI.RevokePermissions.Responses.$200>>;
     getApps({ query, page, limit, workspaceId, }: {
         query?: PrismeaiAPI.SearchApps.QueryParameters['text'];
         page?: PrismeaiAPI.SearchApps.QueryParameters['page'];
         limit?: PrismeaiAPI.SearchApps.QueryParameters['limit'];
         workspaceId?: PrismeaiAPI.SearchApps.QueryParameters['workspaceId'];
-    }): Promise<PrismeaiAPI.SearchApps.Responses.$200>;
-    installApp(workspaceId: PrismeaiAPI.InstallAppInstance.PathParameters['workspaceId'], body: PrismeaiAPI.InstallAppInstance.RequestBody): Promise<PrismeaiAPI.InstallAppInstance.Responses.$200>;
-    updateApp(workspaceId: PrismeaiAPI.ConfigureAppInstance.PathParameters['workspaceId'], slug: PrismeaiAPI.ConfigureAppInstance.PathParameters['slug'], body: PrismeaiAPI.ConfigureAppInstance.RequestBody): Promise<PrismeaiAPI.ConfigureAppInstance.Responses.$200>;
-    uninstallApp(workspaceId: PrismeaiAPI.UninstallAppInstance.PathParameters['workspaceId'], slug: PrismeaiAPI.ConfigureAppInstance.PathParameters['slug']): Promise<PrismeaiAPI.UninstallAppInstance.Responses.$200>;
-    publishApp(body: PrismeaiAPI.PublishApp.RequestBody): Promise<PrismeaiAPI.PublishApp.Responses.$200>;
-    listAppInstances(workspaceId: PrismeaiAPI.ListAppInstances.PathParameters['workspaceId']): Promise<PrismeaiAPI.ListAppInstances.Responses.$200>;
-    fetchImports(workspaceId: PrismeaiAPI.ListAppInstances.Parameters.WorkspaceId): Promise<PrismeaiAPI.ListAppInstances.Responses.$200>;
+    }): Promise<Fetched<PrismeaiAPI.SearchApps.Responses.$200>>;
+    installApp(workspaceId: PrismeaiAPI.InstallAppInstance.PathParameters['workspaceId'], body: PrismeaiAPI.InstallAppInstance.RequestBody): Promise<Fetched<PrismeaiAPI.InstallAppInstance.Responses.$200>>;
+    updateApp(workspaceId: PrismeaiAPI.ConfigureAppInstance.PathParameters['workspaceId'], slug: PrismeaiAPI.ConfigureAppInstance.PathParameters['slug'], body: PrismeaiAPI.ConfigureAppInstance.RequestBody): Promise<Fetched<PrismeaiAPI.ConfigureAppInstance.Responses.$200>>;
+    uninstallApp(workspaceId: PrismeaiAPI.UninstallAppInstance.PathParameters['workspaceId'], slug: PrismeaiAPI.ConfigureAppInstance.PathParameters['slug']): Promise<Fetched<PrismeaiAPI.UninstallAppInstance.Responses.$200>>;
+    publishApp(body: PrismeaiAPI.PublishApp.RequestBody): Promise<Fetched<PrismeaiAPI.PublishApp.Responses.$200>>;
+    listAppInstances(workspaceId: PrismeaiAPI.ListAppInstances.PathParameters['workspaceId']): Promise<Fetched<PrismeaiAPI.ListAppInstances.Responses.$200>>;
     getAppConfig<T>(workspaceId: PrismeaiAPI.GetAppInstanceConfig.Parameters.WorkspaceId, slug: PrismeaiAPI.GetAppInstanceConfig.Parameters.Slug): Promise<T>;
     updateAppConfig(workspaceId: PrismeaiAPI.UpdateAppInstanceConfig.Parameters.WorkspaceId, slug: PrismeaiAPI.UpdateAppInstanceConfig.Parameters.Slug, config: any): Promise<PrismeaiAPI.UpdateAppInstanceConfig.Responses.$200['config']>;
+    getAppInstance(workspaceId: string, slug: string): Promise<Fetched<PrismeaiAPI.GetAppInstance.Responses.$200>>;
+    saveAppInstance(workspaceId: PrismeaiAPI.ConfigureAppInstance.Parameters.WorkspaceId, slug: PrismeaiAPI.ConfigureAppInstance.Parameters.Slug, appInstance: PrismeaiAPI.ConfigureAppInstance.RequestBody): Promise<Fetched<PrismeaiAPI.ConfigureAppInstance.Responses.$200>>;
     uploadFiles(files: string | string[], workspaceId: string): Promise<PrismeaiAPI.UploadFile.Responses.$200>;
     replaceAllImagesData(original: any, workspaceId: string): Promise<any>;
-    callAutomation(workspaceId: string, automation: string): Promise<any>;
+    callAutomation(workspaceId: string, automation: string, params?: any): Promise<Fetched<any>>;
+    testAutomation({ workspaceId, automation, payload, }: {
+        workspaceId: string;
+        automation: string;
+        payload?: Record<string, any>;
+    }): Promise<Fetched<any>>;
+    getWorkspaceUsage(workspaceId: PrismeaiAPI.WorkspaceUsage.Parameters.WorkspaceId, { afterDate, beforeDate, details, }?: {
+        afterDate?: PrismeaiAPI.WorkspaceUsage.Parameters.AfterDate;
+        beforeDate?: PrismeaiAPI.WorkspaceUsage.Parameters.BeforeDate;
+        details?: PrismeaiAPI.WorkspaceUsage.Parameters.Details;
+    }): Promise<Fetched<PrismeaiAPI.WorkspaceUsage.Responses.$200>>;
+    importArchive(archive: File): Promise<PrismeaiAPI.ImportNewWorkspace.Responses.$200>;
+    users(id?: string): UsersEndpoint;
+    workspaces(id: string): WorkspacesEndpoint;
 }
 declare const _default: Api;
 export default _default;

package/dist/lib/endpoints/users.d.ts

@@ -0,0 +1,9 @@
+import { Api } from '../api';
+export declare class UsersEndpoint {
+    private id;
+    private api;
+    constructor(id: string, api: Api);
+    setMeta(k: string, v: any): Promise<void>;
+    deleteMeta(k: string): Promise<void>;
+}
+export default UsersEndpoint;

package/dist/lib/endpoints/workspaces.d.ts

@@ -0,0 +1,9 @@
+import { Api } from '../api';
+import WorkspacesVersionsEndpoint from './workspacesVersions';
+export declare class WorkspacesEndpoint {
+    private id;
+    private api;
+    constructor(id: string, api: Api);
+    get versions(): WorkspacesVersionsEndpoint;
+}
+export default WorkspacesEndpoint;

package/dist/lib/endpoints/workspacesVersions.d.ts

@@ -0,0 +1,10 @@
+import { Api } from '../api';
+export declare class WorkspacesVersionsEndpoint {
+    private workspaceId;
+    private api;
+    constructor(workspaceId: string, api: Api);
+    create(version?: PrismeaiAPI.PublishWorkspaceVersion.RequestBody): void;
+    rollback(versionId: PrismeaiAPI.RollbackWorkspaceVersion.PathParameters['versionId']): void;
+    export(version?: PrismeaiAPI.ExportWorkspaceVersion.Parameters.VersionId): Promise<Blob>;
+}
+export default WorkspacesVersionsEndpoint;

package/dist/lib/events.d.ts

@@ -1,14 +1,38 @@
 import { Socket } from 'socket.io-client';
+import { Api } from './api';
+export type PayloadQuery = Record<string, string | string[]>;
+export type OrQuery = PayloadQuery[];
+export type SearchOptions = Omit<PrismeaiAPI.EventsLongpolling.QueryParameters, 'query' | 'types'> & {
+    payloadQuery?: PayloadQuery | OrQuery;
+    types?: string[];
+};
 export declare class Events {
     protected client: Socket;
     workspaceId: string;
-    constructor(workspaceId: string, token: string, apiHost?: string);
+    private filters;
+    private listenedUserTopics;
+    private listeners;
+    private lastReceivedEventDate;
+    constructor({ workspaceId, token, legacyToken, apiKey, apiHost, filters, api, }: {
+        workspaceId: string;
+        token: string;
+        legacyToken?: string;
+        apiKey?: string;
+        apiHost?: string;
+        filters?: Record<string, any>;
+        api: Api;
+    });
     get socket(): Socket<import("@socket.io/component-emitter").DefaultEventsMap, import("@socket.io/component-emitter").DefaultEventsMap>;
     destroy(): void;
     all(listener: (eventName: string, eventData: Prismeai.PrismeEvent) => void): () => Socket<import("@socket.io/component-emitter").DefaultEventsMap, import("@socket.io/component-emitter").DefaultEventsMap>;
-    on(ev: string, listener: (eventName: string, eventData: Prismeai.PrismeEvent) => void): () => Socket<import("@socket.io/component-emitter").DefaultEventsMap, import("@socket.io/component-emitter").DefaultEventsMap>;
-    emit(event: string, payload?: any): void;
-    once(ev: string, listener: (eventName: string, eventData: Prismeai.PrismeEvent) => void): void;
+    on(ev: string, listener: (eventData: Prismeai.PrismeEvent) => void): () => void;
+    emit(event: string, payload?: any, options?: any): void;
+    listenTopics({ event, topics, }: {
+        event: string;
+        topics: string | string[];
+    }): void;
+    updateFilters(filters: SearchOptions): void;
+    once(ev: string, listener: (eventName: string, eventData: Prismeai.PrismeEvent) => void): () => void;
     close(): void;
 }
 export default Events;

package/dist/lib/fetcher.d.ts

@@ -1,10 +1,22 @@
+export type Fetched<T> = T & {
+    headers?: Record<string, any>;
+};
 export declare class Fetcher {
     host: string;
     token: string | null;
-    constructor(host: string);
+    legacyToken: string | null;
+    overwriteClientId?: string;
+    private clientIdHeader?;
+    protected _apiKey: string | null;
+    language: string | undefined;
+    lastReceivedHeaders?: Record<string, any>;
+    constructor(host: string, clientIdHeader?: string);
+    set apiKey(apiKey: string);
+    prepareRequest(url: string, options?: RequestInit): Promise<Response>;
     protected _fetch<T>(url: string, options?: RequestInit): Promise<T>;
     get<T = any>(url: string): Promise<T>;
-    post<T>(url: string, body?: Record<string, any>): Promise<T>;
+    post<T>(url: string, body?: Record<string, any>, opts?: RequestInit): Promise<T>;
+    put<T>(url: string, body: Record<string, any>): Promise<T>;
     patch<T>(url: string, body: Record<string, any>): Promise<T>;
     delete<T>(url: string): Promise<T>;
 }

package/dist/lib/types.d.ts

@@ -1,11 +1,15 @@
 import '@prisme.ai/types';
 export interface Workspace extends Prismeai.Workspace {
     id: string;
+    updatedAt: Date;
+    updatedBy: string;
+    createdAt: Date;
+    createdBy: string;
 }
 export interface Event<DateType extends Date | string> extends Omit<Prismeai.PrismeEvent, 'createdAt'> {
     createdAt: DateType;
 }
-export declare type EventsFilters = {
+export type EventsFilters = Record<string, string> & {
     afterDate?: PrismeaiAPI.EventsLongpolling.Parameters.AfterDate;
     beforeDate?: PrismeaiAPI.EventsLongpolling.Parameters.BeforeDate;
     text?: PrismeaiAPI.EventsLongpolling.Parameters.Text;