lansenger-sdk-ts 1.0.0

package/dist/oauth.d.ts

@@ -0,0 +1,17 @@
+import { LansengerConfig } from "./config";
+import { FetchFn } from "./http";
+import { UserTokenResult } from "./models";
+export declare function buildAuthorizeUrl(config: LansengerConfig, redirectUri: string, opts?: {
+    scope?: string | string[];
+    state?: string;
+}): string;
+export declare function exchangeCodeForUserToken(config: LansengerConfig, appToken: string, code: string, opts?: {
+    redirect_uri?: string;
+    fetchFn?: FetchFn;
+}): Promise<UserTokenResult>;
+export declare function refreshUserToken(config: LansengerConfig, appToken: string, refreshToken: string, opts?: {
+    scope?: string;
+    fetchFn?: FetchFn;
+}): Promise<UserTokenResult>;
+export declare function parseAuthorizeCallback(queryString: string | Record<string, string>): Record<string, string>;
+export declare function validateCallbackState(callbackState: string, expectedState: string): boolean;

package/dist/oauth.js

@@ -0,0 +1,107 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildAuthorizeUrl = buildAuthorizeUrl;
+exports.exchangeCodeForUserToken = exchangeCodeForUserToken;
+exports.refreshUserToken = refreshUserToken;
+exports.parseAuthorizeCallback = parseAuthorizeCallback;
+exports.validateCallbackState = validateCallbackState;
+const constants_1 = require("./constants");
+const urlHelpers_1 = require("./urlHelpers");
+const http_1 = require("./http");
+const models_1 = require("./models");
+const exceptions_1 = require("./exceptions");
+const crypto_1 = require("crypto");
+function buildAuthorizeUrl(config, redirectUri, opts) {
+    if (!config.passport_url) {
+        throw new exceptions_1.LansengerConfigError("passport_url is required for OAuth2 flows. " +
+            "Set LANSENGER_PASSPORT_URL env var or pass passport_url in config.");
+    }
+    const state = opts?.state || (0, crypto_1.randomUUID)().replace(/-/g, "");
+    let scopeStr;
+    if (opts?.scope == null)
+        scopeStr = constants_1.OAUTH2_SCOPE_BASIC_USER_INFO;
+    else if (Array.isArray(opts.scope))
+        scopeStr = opts.scope.join(",");
+    else
+        scopeStr = opts.scope;
+    const params = new URLSearchParams({
+        appid: config.app_id, response_type: "code", scope: scopeStr,
+        state, redirect_uri: redirectUri,
+    });
+    const baseUrl = config.passport_url.replace(/\/+$/, "") + constants_1.API_ENDPOINTS.oauth2.authorize;
+    return `${baseUrl}?${params.toString()}`;
+}
+async function exchangeCodeForUserToken(config, appToken, code, opts) {
+    if (!code)
+        return new models_1.UserTokenResult({ success: false, error: "code is required" });
+    if (!appToken)
+        return new models_1.UserTokenResult({ success: false, error: "app_token is required" });
+    let url = (0, urlHelpers_1.buildApiUrl)(config, "oauth2", "user_token_create", appToken)
+        + `&grant_type=authorization_code&code=${encodeURIComponent(code)}`;
+    if (opts?.redirect_uri)
+        url += `&redirect_uri=${encodeURIComponent(opts.redirect_uri)}`;
+    const [data, httpErr] = await (0, http_1.doGet)(url, opts?.fetchFn);
+    if (httpErr)
+        return new models_1.UserTokenResult({ success: false, error: httpErr });
+    const errCode = data.errCode ?? -1;
+    if (errCode !== 0) {
+        const msg = data.errMsg || "Unknown error";
+        return new models_1.UserTokenResult({ success: false, error: `API error (errCode=${errCode}): ${msg}` });
+    }
+    const d = data.data || {};
+    return new models_1.UserTokenResult({
+        success: true, user_token: d.userToken, expires_in: d.expiresIn || 7200,
+        refresh_token: d.refreshToken, refresh_expires_in: d.refreshExpiresIn || 2592000,
+        staff_id: d.staffId, scope: d.scope, state: d.state, raw_response: data,
+    });
+}
+async function refreshUserToken(config, appToken, refreshToken, opts) {
+    if (!refreshToken)
+        return new models_1.UserTokenResult({ success: false, error: "refresh_token is required" });
+    if (!appToken)
+        return new models_1.UserTokenResult({ success: false, error: "app_token is required" });
+    let url = (0, urlHelpers_1.buildApiUrl)(config, "oauth2", "refresh_token_create", appToken)
+        + `&grant_type=refresh_token&refresh_token=${encodeURIComponent(refreshToken)}`;
+    if (opts?.scope)
+        url += `&scope=${encodeURIComponent(opts.scope)}`;
+    const [data, httpErr] = await (0, http_1.doGet)(url, opts?.fetchFn);
+    if (httpErr)
+        return new models_1.UserTokenResult({ success: false, error: httpErr });
+    const errCode = data.errCode ?? -1;
+    if (errCode !== 0) {
+        const msg = data.errMsg || "Unknown error";
+        return new models_1.UserTokenResult({ success: false, error: `API error (errCode=${errCode}): ${msg}` });
+    }
+    const d = data.data || {};
+    return new models_1.UserTokenResult({
+        success: true, user_token: d.userToken, expires_in: d.expiresIn || 7200,
+        refresh_token: d.refreshToken, refresh_expires_in: d.refreshExpiresIn || 2592000,
+        staff_id: d.staffId, scope: d.scope, state: d.state, raw_response: data,
+    });
+}
+function parseAuthorizeCallback(queryString) {
+    let params;
+    if (typeof queryString === "object")
+        params = queryString;
+    else {
+        params = {};
+        for (const part of queryString.replace(/^\?/, "").split("&")) {
+            if (part.includes("=")) {
+                const [key, value] = part.split("=", 1);
+                params[key] = value || "";
+            }
+        }
+    }
+    const result = {
+        code: params.code || "", state: params.state || "",
+    };
+    if (params.error)
+        result.error = params.error;
+    if (params.error_description)
+        result.error_description = params.error_description;
+    return result;
+}
+function validateCallbackState(callbackState, expectedState) {
+    return callbackState === expectedState;
+}
+//# sourceMappingURL=oauth.js.map

package/dist/persistence.d.ts

@@ -0,0 +1,26 @@
+export declare class CredentialStore {
+    private filePath;
+    private profile;
+    constructor(filePath?: string, profile?: string);
+    get path(): string;
+    get currentProfile(): string;
+    private migrateLegacy;
+    load(): Record<string, any>;
+    save(state: Record<string, any>): void;
+    private getProfileData;
+    private setProfileData;
+    loadCredentials(): Record<string, string>;
+    saveCredentials(appId: string, appSecret: string, apiGatewayUrl?: string, passportUrl?: string, encodingKey?: string, callbackToken?: string): void;
+    saveCallbackConfig(encodingKey: string, callbackToken?: string): void;
+    loadAppToken(): string | null;
+    saveAppToken(token: string, expiresIn?: number, margin?: number): void;
+    loadUserToken(): Record<string, any>;
+    saveUserToken(userToken: string, refreshToken?: string, expiresIn?: number): void;
+    clearProfile(): void;
+    clear(): void;
+    listProfiles(): string[];
+    getActiveProfile(): string;
+    setActiveProfile(profile: string): void;
+    hasCredentials(): boolean;
+    hasFullConfig(): boolean;
+}

package/dist/persistence.js

@@ -0,0 +1,210 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CredentialStore = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const DEFAULT_STATE_DIR = path.join(os.homedir(), ".lansenger");
+const DEFAULT_STATE_FILE = "sdk_state.json";
+const DEFAULT_PROFILE = "default";
+const LEGACY_KEYS = new Set([
+    "app_id", "app_secret", "api_gateway_url", "passport_url",
+    "encoding_key", "callback_token",
+    "app_token", "app_token_expiry", "user_token", "refresh_token",
+    "user_token_expiry",
+]);
+class CredentialStore {
+    constructor(filePath, profile = DEFAULT_PROFILE) {
+        this.filePath = filePath || path.join(DEFAULT_STATE_DIR, DEFAULT_STATE_FILE);
+        this.profile = profile;
+    }
+    get path() {
+        return this.filePath;
+    }
+    get currentProfile() {
+        return this.profile;
+    }
+    migrateLegacy(state) {
+        if ("profiles" in state)
+            return state;
+        const legacyData = {};
+        for (const [k, v] of Object.entries(state)) {
+            if (LEGACY_KEYS.has(k))
+                legacyData[k] = v;
+        }
+        if (!legacyData.app_id)
+            return state;
+        const newState = {
+            profiles: { [DEFAULT_PROFILE]: legacyData },
+            active_profile: DEFAULT_PROFILE,
+        };
+        this.save(newState);
+        return newState;
+    }
+    load() {
+        if (!fs.existsSync(this.filePath))
+            return {};
+        try {
+            const raw = fs.readFileSync(this.filePath, "utf-8");
+            const data = JSON.parse(raw);
+            return this.migrateLegacy(data);
+        }
+        catch (e) {
+            return {};
+        }
+    }
+    save(state) {
+        const dir = path.dirname(this.filePath);
+        if (!fs.existsSync(dir))
+            fs.mkdirSync(dir, { recursive: true });
+        fs.writeFileSync(this.filePath, JSON.stringify(state, null, 2), "utf-8");
+        try {
+            fs.chmodSync(this.filePath, 0o600);
+        }
+        catch { }
+    }
+    getProfileData(state) {
+        const profiles = state.profiles || {};
+        return profiles[this.profile] || {};
+    }
+    setProfileData(state, data) {
+        if (!state.profiles)
+            state.profiles = {};
+        state.profiles[this.profile] = data;
+        if (!state.active_profile)
+            state.active_profile = DEFAULT_PROFILE;
+        return state;
+    }
+    loadCredentials() {
+        const data = this.getProfileData(this.load());
+        return {
+            app_id: data.app_id || "",
+            app_secret: data.app_secret || "",
+            api_gateway_url: data.api_gateway_url || "",
+            passport_url: data.passport_url || "",
+            encoding_key: data.encoding_key || "",
+            callback_token: data.callback_token || "",
+        };
+    }
+    saveCredentials(appId, appSecret, apiGatewayUrl = "", passportUrl = "", encodingKey = "", callbackToken = "") {
+        const state = this.load();
+        const data = this.getProfileData(state);
+        data.app_id = appId;
+        data.app_secret = appSecret;
+        if (apiGatewayUrl)
+            data.api_gateway_url = apiGatewayUrl;
+        if (passportUrl)
+            data.passport_url = passportUrl;
+        data.encoding_key = encodingKey;
+        data.callback_token = callbackToken;
+        this.save(this.setProfileData(state, data));
+    }
+    saveCallbackConfig(encodingKey, callbackToken = "") {
+        const state = this.load();
+        const data = this.getProfileData(state);
+        data.encoding_key = encodingKey;
+        data.callback_token = callbackToken;
+        this.save(this.setProfileData(state, data));
+    }
+    loadAppToken() {
+        const data = this.getProfileData(this.load());
+        const token = data.app_token;
+        const expiry = data.app_token_expiry || 0;
+        if (token && expiry > Date.now() / 1000)
+            return token;
+        return null;
+    }
+    saveAppToken(token, expiresIn = 7200, margin = 300) {
+        const state = this.load();
+        const data = this.getProfileData(state);
+        data.app_token = token;
+        data.app_token_expiry = Date.now() / 1000 + expiresIn - margin;
+        this.save(this.setProfileData(state, data));
+    }
+    loadUserToken() {
+        const data = this.getProfileData(this.load());
+        return {
+            user_token: data.user_token || "",
+            refresh_token: data.refresh_token || "",
+            user_token_expiry: data.user_token_expiry || 0,
+        };
+    }
+    saveUserToken(userToken, refreshToken = "", expiresIn = 0) {
+        const state = this.load();
+        const data = this.getProfileData(state);
+        data.user_token = userToken;
+        data.refresh_token = refreshToken;
+        if (expiresIn)
+            data.user_token_expiry = Date.now() / 1000 + expiresIn;
+        this.save(this.setProfileData(state, data));
+    }
+    clearProfile() {
+        const state = this.load();
+        const profiles = state.profiles || {};
+        if (this.profile in profiles) {
+            delete profiles[this.profile];
+            this.save(state);
+        }
+    }
+    clear() {
+        if (fs.existsSync(this.filePath)) {
+            fs.unlinkSync(this.filePath);
+        }
+    }
+    listProfiles() {
+        const state = this.load();
+        return Object.keys(state.profiles || {});
+    }
+    getActiveProfile() {
+        const state = this.load();
+        return state.active_profile || DEFAULT_PROFILE;
+    }
+    setActiveProfile(profile) {
+        const state = this.load();
+        state.active_profile = profile;
+        this.save(state);
+    }
+    hasCredentials() {
+        const creds = this.loadCredentials();
+        return !!creds.app_id && !!creds.app_secret;
+    }
+    hasFullConfig() {
+        const creds = this.loadCredentials();
+        return !!creds.app_id && !!creds.app_secret && !!creds.api_gateway_url;
+    }
+}
+exports.CredentialStore = CredentialStore;
+//# sourceMappingURL=persistence.js.map

package/dist/reminders.d.ts

@@ -0,0 +1,10 @@
+import { LansengerConfig } from "./config";
+import { FetchFn } from "./http";
+import { SendMessageResult } from "./models";
+export declare const REMINDER_TYPE_NONE = 0;
+export declare const REMINDER_TYPE_POPUP = 1;
+export declare const REMINDER_TYPE_SMS = 2;
+export declare const REMINDER_TYPE_PHONE = 3;
+export declare function sendReminder(config: LansengerConfig, appToken: string, msgId: string, reminderTypes: number[], userIdList: string[], opts?: {
+    fetchFn?: FetchFn;
+}): Promise<SendMessageResult>;

package/dist/reminders.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.REMINDER_TYPE_PHONE = exports.REMINDER_TYPE_SMS = exports.REMINDER_TYPE_POPUP = exports.REMINDER_TYPE_NONE = void 0;
+exports.sendReminder = sendReminder;
+const urlHelpers_1 = require("./urlHelpers");
+const http_1 = require("./http");
+const models_1 = require("./models");
+exports.REMINDER_TYPE_NONE = 0;
+exports.REMINDER_TYPE_POPUP = 1;
+exports.REMINDER_TYPE_SMS = 2;
+exports.REMINDER_TYPE_PHONE = 3;
+async function sendReminder(config, appToken, msgId, reminderTypes, userIdList, opts) {
+    if (!msgId)
+        return new models_1.SendMessageResult({ success: false, error: "msg_id is required" });
+    if (!reminderTypes || !reminderTypes.length)
+        return new models_1.SendMessageResult({ success: false, error: "reminder_types is required" });
+    if (!userIdList || !userIdList.length)
+        return new models_1.SendMessageResult({ success: false, error: "user_id_list is required" });
+    const url = (0, urlHelpers_1.buildApiUrl)(config, "message", "reminder_create", appToken);
+    const body = { msgId, reminderTypes, userIdList };
+    const [data, httpErr] = await (0, http_1.doPost)(url, body, opts?.fetchFn);
+    if (httpErr)
+        return new models_1.SendMessageResult({ success: false, error: httpErr, retryable: true });
+    const errCode = data.errCode ?? -1;
+    if (errCode !== 0) {
+        const msg = data.errMsg || "Unknown error";
+        return new models_1.SendMessageResult({ success: false, error: `API error (errCode=${errCode}): ${msg}`, operation: "send_reminder", retryable: true });
+    }
+    return new models_1.SendMessageResult({ success: true, operation: "send_reminder", raw_response: data });
+}
+//# sourceMappingURL=reminders.js.map

package/dist/streaming.d.ts

@@ -0,0 +1,9 @@
+import { LansengerConfig } from "./config";
+import { FetchFn } from "./http";
+import { StreamMessageResult } from "./models";
+export declare function createStreamMessage(config: LansengerConfig, appToken: string, receiverId: string, receiverType: string, streamId: string, opts?: {
+    fetchFn?: FetchFn;
+}): Promise<StreamMessageResult>;
+export declare function fetchStreamMessage(config: LansengerConfig, appToken: string, msgId: string, opts?: {
+    fetchFn?: FetchFn;
+}): Promise<StreamMessageResult>;

package/dist/streaming.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createStreamMessage = createStreamMessage;
+exports.fetchStreamMessage = fetchStreamMessage;
+const urlHelpers_1 = require("./urlHelpers");
+const http_1 = require("./http");
+const models_1 = require("./models");
+async function createStreamMessage(config, appToken, receiverId, receiverType, streamId, opts) {
+    if (!receiverId)
+        return new models_1.StreamMessageResult({ success: false, error: "receiver_id is required" });
+    if (!receiverType)
+        return new models_1.StreamMessageResult({ success: false, error: "receiver_type is required" });
+    if (!streamId)
+        return new models_1.StreamMessageResult({ success: false, error: "stream_id is required" });
+    const url = (0, urlHelpers_1.buildApiUrl)(config, "sse", "msg_create", appToken);
+    const body = { receiverId, receiverType, streamId };
+    const [data, httpErr] = await (0, http_1.doPost)(url, body, opts?.fetchFn);
+    if (httpErr)
+        return new models_1.StreamMessageResult({ success: false, error: httpErr });
+    const [ok, apiErr] = (0, http_1.parseApiResponse)(data);
+    if (!ok)
+        return new models_1.StreamMessageResult({ success: false, error: apiErr });
+    const d = data.data || {};
+    return new models_1.StreamMessageResult({ success: true, message_id: d.msgId, raw_response: data });
+}
+async function fetchStreamMessage(config, appToken, msgId, opts) {
+    if (!msgId)
+        return new models_1.StreamMessageResult({ success: false, error: "msg_id is required" });
+    const url = (0, urlHelpers_1.buildApiUrl)(config, "sse", "msg_fetch", appToken);
+    const body = { msgId };
+    const [data, httpErr] = await (0, http_1.doPost)(url, body, opts?.fetchFn);
+    if (httpErr)
+        return new models_1.StreamMessageResult({ success: false, error: httpErr });
+    const [ok, apiErr] = (0, http_1.parseApiResponse)(data);
+    if (!ok)
+        return new models_1.StreamMessageResult({ success: false, error: apiErr });
+    const d = data.data || {};
+    return new models_1.StreamMessageResult({ success: true, message_id: d.msgId, raw_response: data });
+}
+//# sourceMappingURL=streaming.js.map

package/dist/todos.d.ts

@@ -0,0 +1,75 @@
+import { LansengerConfig } from "./config";
+import { FetchFn } from "./http";
+import { TodoTaskCreateResult, TodoTaskInfoResult, TodoTaskListResult, TodoTaskStatusCountResult, TodoTaskExecutorListResult } from "./models";
+export declare const TODO_TODO_STATUS_PENDING_READ = "11";
+export declare const TODO_TODO_STATUS_READ = "12";
+export declare const TODO_TODO_STATUS_PENDING_DO = "21";
+export declare const TODO_TODO_STATUS_DONE = "22";
+export declare const TODO_TYPE_NOTIFICATION = 1;
+export declare const TODO_TYPE_APPROVAL = 2;
+export declare function createTodoTask(config: LansengerConfig, appToken: string, title: string, link: string, pcLink: string, executorIds: string[], orgId: string, type?: number, opts?: {
+    source_id?: string;
+    desc?: string;
+    sender_id?: string;
+    user_token?: string;
+    fetchFn?: FetchFn;
+}): Promise<TodoTaskCreateResult>;
+export declare function updateTodoTask(config: LansengerConfig, appToken: string, todotaskId: string, title: string, link: string, pcLink: string, orgId: string, opts?: {
+    desc?: string;
+    user_token?: string;
+    fetchFn?: FetchFn;
+}): Promise<TodoTaskCreateResult>;
+export declare function updateTodoTaskStatus(config: LansengerConfig, appToken: string, todotaskId: string, status: string, orgId: string, opts?: {
+    staff_id?: string;
+    user_token?: string;
+    fetchFn?: FetchFn;
+}): Promise<TodoTaskCreateResult>;
+export declare function deleteTodoTask(config: LansengerConfig, appToken: string, todotaskId: string, orgId: string, opts?: {
+    staff_id?: string;
+    user_token?: string;
+    fetchFn?: FetchFn;
+}): Promise<TodoTaskCreateResult>;
+export declare function fetchTodoTaskList(config: LansengerConfig, appToken: string, orgId: string, opts?: {
+    app_ids?: string[];
+    staff_id?: string;
+    status_list?: string[];
+    user_token?: string;
+    fetchFn?: FetchFn;
+}): Promise<TodoTaskListResult>;
+export declare function fetchTodoTaskBySourceId(config: LansengerConfig, appToken: string, sourceId: string, orgId: string, opts?: {
+    staff_id?: string;
+    user_token?: string;
+    fetchFn?: FetchFn;
+}): Promise<TodoTaskInfoResult>;
+export declare function fetchTodoTaskById(config: LansengerConfig, appToken: string, todotaskId: string, orgId: string, opts?: {
+    staff_id?: string;
+    user_token?: string;
+    fetchFn?: FetchFn;
+}): Promise<TodoTaskInfoResult>;
+export declare function fetchTodoTaskStatusCounts(config: LansengerConfig, appToken: string, staffId: string, orgId: string, opts?: {
+    app_id?: string;
+    status_list?: string[];
+    user_token?: string;
+    fetchFn?: FetchFn;
+}): Promise<TodoTaskStatusCountResult>;
+export declare function updateExecutorStatus(config: LansengerConfig, appToken: string, executorStatusList: Record<string, string>[], orgId: string, opts?: {
+    todotask_id?: string;
+    user_token?: string;
+    fetchFn?: FetchFn;
+}): Promise<TodoTaskCreateResult>;
+export declare function addExecutors(config: LansengerConfig, appToken: string, executorIds: string[], orgId: string, opts?: {
+    todotask_id?: string;
+    user_token?: string;
+    fetchFn?: FetchFn;
+}): Promise<TodoTaskCreateResult>;
+export declare function deleteExecutors(config: LansengerConfig, appToken: string, executorIds: string[], orgId: string, opts?: {
+    todotask_id?: string;
+    user_token?: string;
+    fetchFn?: FetchFn;
+}): Promise<TodoTaskCreateResult>;
+export declare function fetchExecutorList(config: LansengerConfig, appToken: string, todotaskId: string, orgId: string, opts?: {
+    staff_id?: string;
+    status_list?: string[];
+    user_token?: string;
+    fetchFn?: FetchFn;
+}): Promise<TodoTaskExecutorListResult>;