@intra-mart/smartlime 0.0.1-beta

package/.gitattributes

@@ -0,0 +1 @@
+* text=auto eol=crlf

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021 accelplatform
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,7 @@
+# expoで使用できるintra mart accelplatform SDK
+## プラットフォーム
+- [x] ios
+- [x] android
+
+## ライセンス
+MIT

package/lib/_shared/renderTarget.d.ts

@@ -0,0 +1,14 @@
+type ForceRender = () => void;
+export declare const createRenderTarget: () => {
+    addEventListener: (callback: ForceRender) => void;
+    removeEventListener: (callback: ForceRender) => void;
+    dispatch: () => void;
+};
+export type CreateRenderTarget = typeof createRenderTarget;
+export type RenderTarget = ReturnType<CreateRenderTarget>;
+export declare const useRenderTarget: () => {
+    addEventListener: (callback: ForceRender) => void;
+    removeEventListener: (callback: ForceRender) => void;
+    dispatch: () => void;
+};
+export {};

package/lib/_shared/renderTarget.js

@@ -0,0 +1,31 @@
+import { useRef } from 'react';
+export const createRenderTarget = () => {
+    const listenerList = [];
+    const addEventListener = (callback) => {
+        listenerList.push(callback);
+    };
+    const removeEventListener = (callback) => {
+        for (let i = 0, l = listenerList.length; i < l; i++) {
+            if (listenerList[i] === callback) {
+                listenerList.splice(i, 1);
+                return;
+            }
+        }
+    };
+    const dispatch = () => {
+        for (let i = 0, l = listenerList.length; i < l; i++) {
+            const listener = listenerList[i];
+            if (listener)
+                listener();
+        }
+    };
+    return {
+        addEventListener,
+        removeEventListener,
+        dispatch,
+    };
+};
+export const useRenderTarget = () => {
+    const ref = useRef(createRenderTarget());
+    return ref.current;
+};

package/lib/index.d.ts

@@ -0,0 +1,14 @@
+export { Smartlime } from './packages/Smartlime';
+export { IMTenant } from './packages/Tenant';
+export * from './packages/Tenant/hooks';
+export { IMOAuth } from './packages/OAuth';
+export * from './packages/OAuth/hooks';
+export { useIMFetch } from './packages/Fetch';
+export { IMMe } from './packages/Me';
+export * from './packages/Me/hooks';
+export { IMSession } from './packages/Session';
+export * from './packages/Session/hooks';
+export { IMSearch } from './packages/Search';
+export * from './packages/Search/hooks';
+export { IMWebView } from './packages/WebView';
+export * from './packages/WebView/hooks';

package/lib/index.js

@@ -0,0 +1,18 @@
+/*
+  TODO
+  consider separating the entry points in "exports" in package.json.
+*/
+export { Smartlime } from './packages/Smartlime';
+export { IMTenant } from './packages/Tenant';
+export * from './packages/Tenant/hooks';
+export { IMOAuth } from './packages/OAuth';
+export * from './packages/OAuth/hooks';
+export { useIMFetch } from './packages/Fetch';
+export { IMMe } from './packages/Me';
+export * from './packages/Me/hooks';
+export { IMSession } from './packages/Session';
+export * from './packages/Session/hooks';
+export { IMSearch } from './packages/Search';
+export * from './packages/Search/hooks';
+export { IMWebView } from './packages/WebView';
+export * from './packages/WebView/hooks';

package/lib/packages/Fetch/IMFecthError.d.ts

@@ -0,0 +1,4 @@
+export declare const errorType = "IMFecthError";
+export declare class IMFecthError extends Error {
+    constructor(message: string, options?: ErrorOptions);
+}

package/lib/packages/Fetch/IMFecthError.js

@@ -0,0 +1,10 @@
+export const errorType = 'IMFecthError';
+export class IMFecthError extends Error {
+    constructor(message, options) {
+        super(message, options);
+        if (Error.captureStackTrace) {
+            Error.captureStackTrace(this, IMFecthError);
+        }
+        this.name = errorType;
+    }
+}

package/lib/packages/Fetch/index.d.ts

@@ -0,0 +1,14 @@
+import { Context as DefaultContext } from '../OAuth/Context';
+export type IMJson = {
+    error?: boolean;
+    errorMessage?: string;
+    data?: Record<string, unknown>;
+};
+interface IMResponse<T> extends Response {
+    json: () => Promise<T extends IMJson ? T & IMJson : undefined extends T ? IMJson : T>;
+}
+type UseIMFetch = (option?: {
+    noValidate?: boolean;
+}, context?: typeof DefaultContext) => <T>(input: string, init?: RequestInit) => Promise<IMResponse<T>>;
+export declare const useIMFetch: UseIMFetch;
+export {};

package/lib/packages/Fetch/index.js

@@ -0,0 +1,112 @@
+import { useCallback, useContext } from 'react';
+import { useIMBaseUrl } from '../..';
+import { join } from '../../utils/path';
+import { Context as DefaultContext } from '../OAuth/Context';
+import { IMOAuthError } from '../OAuth/IMOAuthError';
+import { IMFecthError } from './IMFecthError';
+const fetchWrapper = async (token, input, init = {}) => {
+    const response = await fetch(input, {
+        credentials: 'omit',
+        ...init,
+        headers: {
+            'X-Intramart-Session': 'never',
+            ...init.headers,
+            Authorization: `Bearer ${token}`,
+        },
+    });
+    return response;
+};
+const correctionAuthMethod = (input) => {
+    if (input.startsWith('/api/bearer')) {
+        if (input.startsWith('/api/bearer/workflow'))
+            throw new IMFecthError('api/bearer is not available in the workflow API, api/oauth should be used.');
+        return input;
+    }
+    if (input.startsWith('/api/oauth')) {
+        if (input.startsWith('/api/oauth/workflow') ||
+            input.startsWith('/api/oauth/immaster'))
+            return input;
+        throw new IMFecthError('api/oauth is not available in the API except for workflow or immaster, please use api/bearer.');
+    }
+    if (input.startsWith('/api/workflow') || input.startsWith('/api/immaster'))
+        return input.replace(/^\/api\//, '/api/oauth/');
+    if (input.startsWith('/api/'))
+        return input.replace(/^\/api\//, '/api/bearer/');
+    return input;
+};
+const validateRelativePath = (input) => {
+    if (/^.+:\/\//.test(input))
+        return false;
+    return true;
+};
+const validateImApiPath = (input) => {
+    if (input.startsWith('/api'))
+        return true;
+    return false;
+};
+const correctionInput = (input, baseUrl, noValidate = false) => {
+    // 外部にトークンを送りたいケースが想定できないためnoValidateがtrueでも相対パスだけは強制する
+    const valid = validateRelativePath(input);
+    if (!valid)
+        throw new IMFecthError('input must be a relative path');
+    const urlWithCorrectedSlash = `${input.startsWith('/') ? '' : '/'}${input}`;
+    if (!noValidate) {
+        if (validateImApiPath(urlWithCorrectedSlash)) {
+            const correctedUrl = correctionAuthMethod(urlWithCorrectedSlash);
+            return join(baseUrl, correctedUrl);
+        }
+    }
+    return join(baseUrl, urlWithCorrectedSlash);
+};
+const checkUnauthorizedResponse = async (response) => {
+    if (response.status === 401) {
+        try {
+            const clone = response.clone();
+            const json = await clone.json();
+            if (json.error === 'invalid_token')
+                return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    return false;
+};
+export const useIMFetch = (option = { noValidate: false }, context) => {
+    const oauthContext = useContext(context || DefaultContext);
+    const baseUrl = useIMBaseUrl();
+    if (oauthContext == null) {
+        throw new IMFecthError('useIMToken requires either a Context provide or an ancestor element with a IMOAuthProvider.');
+    }
+    return useCallback(async (input, init = {}) => {
+        const token = oauthContext.getToken();
+        if (!token) {
+            throw new IMFecthError(`not yet authorized`);
+        }
+        const correctedInput = correctionInput(input, baseUrl, option.noValidate);
+        try {
+            const response = await fetchWrapper(token, correctedInput, init);
+            if (await checkUnauthorizedResponse(response)) {
+                await oauthContext.refresh();
+                const tokenAfterRefresh = oauthContext.getToken();
+                if (tokenAfterRefresh != null) {
+                    const reFetchResponse = await fetchWrapper(tokenAfterRefresh, correctedInput, init);
+                    if (await checkUnauthorizedResponse(reFetchResponse)) {
+                        throw new IMFecthError('token is invalid.');
+                    }
+                    return reFetchResponse;
+                }
+            }
+            return response;
+        }
+        catch (e) {
+            if (e instanceof IMOAuthError || e instanceof IMFecthError) {
+                oauthContext.destroy();
+                throw new IMFecthError('token has been destroyed.', {
+                    cause: e,
+                });
+            }
+            throw e;
+        }
+    }, [oauthContext, baseUrl]);
+};

package/lib/packages/Me/Context.d.ts

@@ -0,0 +1,10 @@
+/// <reference types="react" />
+import { ErrorResult, SuccessResult } from '.';
+import { RenderTarget } from '../../_shared/renderTarget';
+import { Me } from './type';
+export interface MeContext {
+    getMe: () => Me | null;
+    request: () => Promise<SuccessResult | ErrorResult>;
+    meStateRenderTarget: RenderTarget;
+}
+export declare const Context: import("react").Context<MeContext | null>;

package/lib/packages/Me/Context.js

@@ -0,0 +1,2 @@
+import { createContext } from 'react';
+export const Context = createContext(null);

package/lib/packages/Me/IMMeError.d.ts

@@ -0,0 +1,4 @@
+export declare const errorType = "IMMeError";
+export declare class IMMeError extends Error {
+    constructor(message: string, options?: ErrorOptions);
+}

package/lib/packages/Me/IMMeError.js

@@ -0,0 +1,10 @@
+export const errorType = 'IMMeError';
+export class IMMeError extends Error {
+    constructor(message, options) {
+        super(message, options);
+        if (Error.captureStackTrace) {
+            Error.captureStackTrace(this, IMMeError);
+        }
+        this.name = errorType;
+    }
+}

package/lib/packages/Me/hooks/index.d.ts

@@ -0,0 +1,2 @@
+export * from './useMe';
+export * from './useMeState';

package/lib/packages/Me/hooks/index.js

@@ -0,0 +1,2 @@
+export * from './useMe';
+export * from './useMeState';

package/lib/packages/Me/hooks/useMe.d.ts

@@ -0,0 +1,6 @@
+import { Context as DefaultContext } from '../Context';
+export declare const useMe: (Context?: typeof DefaultContext) => {
+    getMe: () => import("../type").Me | null;
+    request: () => Promise<import("..").SuccessResult | import("..").ErrorResult>;
+    update: () => Promise<import("..").SuccessResult | import("..").ErrorResult>;
+};

package/lib/packages/Me/hooks/useMe.js

@@ -0,0 +1,11 @@
+import { useContext } from 'react';
+import { Context as DefaultContext } from '../Context';
+import { IMMeError } from '../IMMeError';
+export const useMe = (Context) => {
+    const meContext = useContext(Context || DefaultContext);
+    if (meContext == null) {
+        throw new IMMeError('useMe requires either a Context provide or an ancestor element with a IMMeProvider.');
+    }
+    const { getMe, request } = meContext;
+    return { getMe, request, update: request };
+};

package/lib/packages/Me/hooks/useMeState.d.ts

@@ -0,0 +1,2 @@
+import { Context as DefaultContext } from '../Context';
+export declare const useMeState: (Context?: typeof DefaultContext) => import("../type").Me | null;

package/lib/packages/Me/hooks/useMeState.js

@@ -0,0 +1,21 @@
+import { useContext, useEffect, useReducer, useRef } from 'react';
+import { Context as DefaultContext } from '../Context';
+import { IMMeError } from '../IMMeError';
+export const useMeState = (Context) => {
+    const initRef = useRef(true);
+    const [, forceRender] = useReducer((s) => s + 1, 0);
+    const meContext = useContext(Context || DefaultContext);
+    if (meContext == null) {
+        throw new IMMeError('useMeState requires either a Context provide or an ancestor element with a IMMeProvider.');
+    }
+    if (initRef.current) {
+        initRef.current = false;
+        meContext.meStateRenderTarget.addEventListener(forceRender);
+    }
+    useEffect(() => {
+        return () => {
+            meContext.meStateRenderTarget.removeEventListener(forceRender);
+        };
+    }, []);
+    return meContext.getMe();
+};

package/lib/packages/Me/index.d.ts

@@ -0,0 +1,22 @@
+/// <reference types="react" />
+import { RenderTarget } from '../../_shared/renderTarget';
+import { Context as DefaultContext } from './Context';
+import { Me } from './type';
+export interface MeResponse {
+    error: boolean;
+    data: Me;
+}
+export interface SuccessResult {
+    status: 'success';
+}
+export interface ErrorResult {
+    status: 'error';
+}
+export declare const useRequestIMMe: (setter: ReturnType<typeof useMeStateRef>[1]) => () => Promise<SuccessResult | ErrorResult>;
+declare const useMeStateRef: (renderTarget: RenderTarget) => readonly [import("react").MutableRefObject<Me | null>, (state: Me, silent?: boolean) => void, () => Me | null];
+export interface IMMeProps {
+    children: JSX.Element;
+    meContext?: typeof DefaultContext;
+}
+export declare const IMMe: ({ children, meContext }: IMMeProps) => JSX.Element;
+export {};

package/lib/packages/Me/index.js

@@ -0,0 +1,55 @@
+import { useCallback, useRef } from 'react';
+import { useRenderTarget } from '../../_shared/renderTarget';
+import { useIMFetch } from '../Fetch';
+import { Context as DefaultContext } from './Context';
+import { IMMeError } from './IMMeError';
+export const useRequestIMMe = (setter) => {
+    const imFetch = useIMFetch();
+    const request = useCallback(async () => {
+        try {
+            const response = await imFetch('api/bearer/smacolow/me', {
+                headers: {
+                    Accept: 'application/json',
+                },
+                method: 'GET',
+            });
+            if (response.status === 200) {
+                const json = await response.json();
+                if (!json.error) {
+                    setter(json.data);
+                    return { status: 'success' };
+                }
+            }
+            throw new IMMeError('failed to get me information.');
+        }
+        catch {
+            return { status: 'error' };
+        }
+    }, [imFetch]);
+    return request;
+};
+const useMeStateRef = (renderTarget) => {
+    const ref = useRef(null);
+    const setter = useCallback((state, silent) => {
+        if (ref.current === state)
+            return;
+        ref.current = state;
+        if (!silent)
+            renderTarget.dispatch();
+    }, []);
+    const getter = useCallback(() => ref.current, []);
+    return [ref, setter, getter];
+};
+export const IMMe = ({ children, meContext }) => {
+    const Context = meContext || DefaultContext;
+    const contextRef = useRef();
+    const meStateRenderTarget = useRenderTarget();
+    const [, setMe, getMe] = useMeStateRef(meStateRenderTarget);
+    const request = useRequestIMMe(setMe);
+    contextRef.current = {
+        getMe,
+        request,
+        meStateRenderTarget,
+    };
+    return (<Context.Provider value={contextRef.current}>{children}</Context.Provider>);
+};

package/lib/packages/Me/type.d.ts

@@ -0,0 +1,85 @@
+export interface AllDepartment {
+    companyCd: string;
+    departmentCd: string;
+    departmentFullName: string;
+    departmentName: string;
+    departmentSearchName: string;
+    departmentSetCd: string;
+    departmentShortName: string;
+}
+export interface Company {
+    companyCd: string;
+    companyName: string;
+    companyShortName: string;
+    companySearchName: string;
+}
+export interface Post {
+    companyCd: string;
+    departmentCd: string;
+    departmentFullName: string;
+    departmentName: string;
+    departmentSearchName: string;
+    departmentSetCd: string;
+    departmentShortName: string;
+    postCd: string;
+    postName: string;
+    rank: number;
+}
+export interface PublicGroup {
+    publicGroupCd: string;
+    publicGroupFullName: string;
+    publicGroupName: string;
+    publicGroupSearchName: string;
+    publicGroupSetCd: string;
+    publicGroupShortName: string;
+}
+export interface PublicGroupRole {
+    publicGroupCd: string;
+    publicGroupFullName: string;
+    publicGroupName: string;
+    publicGroupSearchName: string;
+    publicGroupSetCd: string;
+    publicGroupShortName: string;
+    rank: number;
+    roleCd: string;
+    roleName: string;
+}
+export interface UserCategory {
+    categoryCd: string;
+    categoryItemCd: string;
+    categoryItemName: string;
+    categoryName: string;
+}
+export interface Me {
+    calendarId: string;
+    firstDayOfWeek: 1 | 2 | 3 | 4 | 5 | 6 | 7;
+    locale: string;
+    tenantId: string;
+    timeZone: string;
+    userCd: string;
+    allDepartments: AllDepartment[];
+    allPosts: Post[];
+    companyList: Company[];
+    publicGroupList: PublicGroup[];
+    publicGroupRoleList: PublicGroupRole[];
+    userCategoryList: UserCategory[];
+    address1: string;
+    address2: string;
+    address3: string;
+    countryCd: string;
+    emailAddress1: string;
+    emailAddress2: string;
+    extensionFaxNumber: string;
+    extensionNumber: string;
+    faxNumber: string;
+    mobileEmailAddress: string;
+    mobileNumber: string;
+    notes: string;
+    sex: string;
+    telephoneNumber: string;
+    url: string;
+    userName: string;
+    userSearchName: string;
+    zipCode: string;
+    profileImage: string;
+}

package/lib/packages/Me/type.js

@@ -0,0 +1 @@
+export {};

package/lib/packages/OAuth/Context.d.ts

@@ -0,0 +1,14 @@
+/// <reference types="react" />
+import { AuthState, StartAuthResult } from '.';
+import { RenderTarget } from '../../_shared/renderTarget';
+export interface OAuthContext {
+    getAuthState: () => AuthState;
+    getToken: () => string | null;
+    getTokenAsync: () => Promise<string | null>;
+    refresh: () => Promise<void>;
+    destroy: () => Promise<void>;
+    startAuth: () => Promise<StartAuthResult>;
+    tokenRenderTarget: RenderTarget;
+    authStateRenderTarget: RenderTarget;
+}
+export declare const Context: import("react").Context<OAuthContext | null>;

package/lib/packages/OAuth/Context.js

@@ -0,0 +1,2 @@
+import { createContext } from 'react';
+export const Context = createContext(null);

package/lib/packages/OAuth/IMOAuthError.d.ts

@@ -0,0 +1,4 @@
+export declare const errorType = "IMOAuthError";
+export declare class IMOAuthError extends Error {
+    constructor(message: string, options?: ErrorOptions);
+}

package/lib/packages/OAuth/IMOAuthError.js

@@ -0,0 +1,10 @@
+export const errorType = 'IMOAuthError';
+export class IMOAuthError extends Error {
+    constructor(message, options) {
+        super(message, options);
+        if (Error.captureStackTrace) {
+            Error.captureStackTrace(this, IMOAuthError);
+        }
+        this.name = errorType;
+    }
+}

package/lib/packages/OAuth/hooks/index.d.ts

@@ -0,0 +1,5 @@
+export * from './useIMOAuth';
+export * from './useIMToken';
+export * from './useStartAuth';
+export * from './useAuthState';
+export * from './useAuthStateEffect';

package/lib/packages/OAuth/hooks/index.js

@@ -0,0 +1,5 @@
+export * from './useIMOAuth';
+export * from './useIMToken';
+export * from './useStartAuth';
+export * from './useAuthState';
+export * from './useAuthStateEffect';

package/lib/packages/OAuth/hooks/useAuthState.d.ts

@@ -0,0 +1,2 @@
+import { Context as DefaultContext } from '../Context';
+export declare const useAuthState: (Context?: typeof DefaultContext) => import("..").AuthState;

package/lib/packages/OAuth/hooks/useAuthState.js

@@ -0,0 +1,25 @@
+import { useContext, useEffect, useReducer, useRef } from 'react';
+import { Context as DefaultContext } from '../Context';
+import { IMOAuthError } from '../IMOAuthError';
+export const useAuthState = (Context) => {
+    const initRef = useRef(true);
+    const [, forceRender] = useReducer((s) => s + 1, 0);
+    const oauthContext = useContext(Context || DefaultContext);
+    if (oauthContext == null) {
+        throw new IMOAuthError('useAuthState requires either a Context provide or an ancestor element with a IMOAuthProvider.');
+    }
+    if (initRef.current) {
+        initRef.current = false;
+        oauthContext.authStateRenderTarget.addEventListener(forceRender);
+    }
+    useEffect(() => {
+        return () => {
+            oauthContext.authStateRenderTarget.removeEventListener(forceRender);
+        };
+    }, []);
+    const state = oauthContext.getAuthState();
+    if (state == null) {
+        throw new IMOAuthError('auth status is null this is an exception that does not normally occur please create a new issue at https://github.com/accelplatform/smartlime/issues');
+    }
+    return state;
+};

package/lib/packages/OAuth/hooks/useAuthStateEffect.d.ts

@@ -0,0 +1,6 @@
+import { AuthState } from '..';
+/**
+ * sugar syntax that sets the return value of "useAuthState" to the deps of "useEffect"
+ * this may be deprecated in the future
+ */
+export declare const useAuthStateEffect: (callBack: (state: AuthState) => ReturnType<React.EffectCallback>) => void;

package/lib/packages/OAuth/hooks/useAuthStateEffect.js

@@ -0,0 +1,14 @@
+import { useEffect } from 'react';
+import { useAuthState } from '.';
+/**
+ * sugar syntax that sets the return value of "useAuthState" to the deps of "useEffect"
+ * this may be deprecated in the future
+ */
+export const useAuthStateEffect = (callBack) => {
+    const state = useAuthState();
+    /*
+      * error because Destructor is using unique symbol
+      * use @ts-ignore to provide type safety for useAuthStateEffect users
+    @ts-ignore*/
+    useEffect(() => callBack(state), [state]);
+};

package/lib/packages/OAuth/hooks/useIMOAuth.d.ts

@@ -0,0 +1,7 @@
+import { Context as DefaultContext } from '../Context';
+export declare const useIMOAuth: (Context?: typeof DefaultContext) => {
+    getToken: () => string | null;
+    getTokenAsync: () => Promise<string | null>;
+    refresh: () => Promise<void>;
+    destroy: () => Promise<void>;
+};

package/lib/packages/OAuth/hooks/useIMOAuth.js

@@ -0,0 +1,13 @@
+import { useContext, useMemo } from 'react';
+import { Context as DefaultContext } from '../Context';
+import { IMOAuthError } from '../IMOAuthError';
+export const useIMOAuth = (Context) => {
+    const oauthContext = useContext(Context || DefaultContext);
+    if (oauthContext == null) {
+        throw new IMOAuthError('useIMOAuth requires either a Context provide or an ancestor element with a IMOAuthProvider.');
+    }
+    return useMemo(() => {
+        const { getToken, getTokenAsync, refresh, destroy } = oauthContext;
+        return { getToken, getTokenAsync, refresh, destroy };
+    }, [oauthContext]);
+};

package/lib/packages/OAuth/hooks/useIMToken.d.ts

@@ -0,0 +1,2 @@
+import { Context as DefaultContext } from '../Context';
+export declare const useIMToken: (Context?: typeof DefaultContext) => string | null;