@revisium/core 0.9.1 → 0.9.2

package/dist/prisma/seed/__generated__/seed.d.ts

@@ -0,0 +1,285 @@
+export interface Permission {
+    action: string;
+    subject: string;
+    condition: object;
+}
+export type PermissionAction = string;
+export type PermissionSubject = string;
+export interface Role {
+    name: string;
+    level: string;
+    permissions: string[];
+}
+export type RoleLevel = string;
+export type QueryParamsType = Record<string | number, any>;
+export type ResponseFormat = keyof Omit<Body, 'body' | 'bodyUsed'>;
+export interface FullRequestParams extends Omit<RequestInit, 'body'> {
+    secure?: boolean;
+    path: string;
+    type?: ContentType;
+    query?: QueryParamsType;
+    format?: ResponseFormat;
+    body?: unknown;
+    baseUrl?: string;
+    cancelToken?: CancelToken;
+}
+export type RequestParams = Omit<FullRequestParams, 'body' | 'method' | 'query' | 'path'>;
+export interface ApiConfig<SecurityDataType = unknown> {
+    baseUrl?: string;
+    baseApiParams?: Omit<RequestParams, 'baseUrl' | 'cancelToken' | 'signal'>;
+    securityWorker?: (securityData: SecurityDataType | null) => Promise<RequestParams | void> | RequestParams | void;
+    customFetch?: typeof fetch;
+}
+export interface HttpResponse<D extends unknown, E extends unknown = unknown> extends Response {
+    data: D;
+    error: E;
+}
+type CancelToken = Symbol | string | number;
+export declare enum ContentType {
+    Json = "application/json",
+    FormData = "multipart/form-data",
+    UrlEncoded = "application/x-www-form-urlencoded",
+    Text = "text/plain"
+}
+export declare class HttpClient<SecurityDataType = unknown> {
+    baseUrl: string;
+    private securityData;
+    private securityWorker?;
+    private abortControllers;
+    private customFetch;
+    private baseApiParams;
+    constructor(apiConfig?: ApiConfig<SecurityDataType>);
+    setSecurityData: (data: SecurityDataType | null) => void;
+    protected encodeQueryParam(key: string, value: any): string;
+    protected addQueryParam(query: QueryParamsType, key: string): string;
+    protected addArrayQueryParam(query: QueryParamsType, key: string): any;
+    protected toQueryString(rawQuery?: QueryParamsType): string;
+    protected addQueryParams(rawQuery?: QueryParamsType): string;
+    private contentFormatters;
+    protected mergeRequestParams(params1: RequestParams, params2?: RequestParams): RequestParams;
+    protected createAbortSignal: (cancelToken: CancelToken) => AbortSignal | undefined;
+    abortRequest: (cancelToken: CancelToken) => void;
+    request: <T = any, E = any>({ body, secure, path, type, query, format, baseUrl, cancelToken, ...params }: FullRequestParams) => Promise<T>;
+}
+export declare class SeedApi<SecurityDataType extends unknown> extends HttpClient<SecurityDataType> {
+    permission: {
+        permissionList: (query: {
+            first: number;
+            after?: string;
+        }, params?: RequestParams) => Promise<{
+            edges: {
+                cursor: string;
+                node: {
+                    id: string;
+                    versionId: string;
+                    createdAt: string;
+                    readonly: boolean;
+                };
+            }[];
+            pageInfo: {
+                startCursor: string;
+                endCursor: string;
+                hasNextPage: boolean;
+                hasPreviousPage: boolean;
+            };
+            totalCount: number;
+        }>;
+        permissionDetail: (id: string, params?: RequestParams) => Promise<Permission>;
+        permissionCreate: (id: string, data: Permission, params?: RequestParams) => Promise<Permission>;
+        permissionUpdate: (id: string, data: Permission, params?: RequestParams) => Promise<Permission>;
+        permissionDelete: (id: string, params?: RequestParams) => Promise<boolean>;
+        referencesByRoleDetail: (id: string, query: {
+            first: number;
+            after?: string;
+        }, params?: RequestParams) => Promise<{
+            edges: {
+                cursor: string;
+                node: {
+                    id: string;
+                    versionId: string;
+                    createdAt: string;
+                    readonly: boolean;
+                };
+            }[];
+            pageInfo: {
+                startCursor: string;
+                endCursor: string;
+                hasNextPage: boolean;
+                hasPreviousPage: boolean;
+            };
+            totalCount: number;
+        }>;
+    };
+    permissionAction: {
+        permissionActionList: (query: {
+            first: number;
+            after?: string;
+        }, params?: RequestParams) => Promise<{
+            edges: {
+                cursor: string;
+                node: {
+                    id: string;
+                    versionId: string;
+                    createdAt: string;
+                    readonly: boolean;
+                };
+            }[];
+            pageInfo: {
+                startCursor: string;
+                endCursor: string;
+                hasNextPage: boolean;
+                hasPreviousPage: boolean;
+            };
+            totalCount: number;
+        }>;
+        permissionActionDetail: (id: string, params?: RequestParams) => Promise<string>;
+        permissionActionCreate: (id: string, data: PermissionAction, params?: RequestParams) => Promise<string>;
+        permissionActionUpdate: (id: string, data: PermissionAction, params?: RequestParams) => Promise<string>;
+        permissionActionDelete: (id: string, params?: RequestParams) => Promise<boolean>;
+        referencesByPermissionDetail: (id: string, query: {
+            first: number;
+            after?: string;
+        }, params?: RequestParams) => Promise<{
+            edges: {
+                cursor: string;
+                node: {
+                    id: string;
+                    versionId: string;
+                    createdAt: string;
+                    readonly: boolean;
+                };
+            }[];
+            pageInfo: {
+                startCursor: string;
+                endCursor: string;
+                hasNextPage: boolean;
+                hasPreviousPage: boolean;
+            };
+            totalCount: number;
+        }>;
+    };
+    permissionSubject: {
+        permissionSubjectList: (query: {
+            first: number;
+            after?: string;
+        }, params?: RequestParams) => Promise<{
+            edges: {
+                cursor: string;
+                node: {
+                    id: string;
+                    versionId: string;
+                    createdAt: string;
+                    readonly: boolean;
+                };
+            }[];
+            pageInfo: {
+                startCursor: string;
+                endCursor: string;
+                hasNextPage: boolean;
+                hasPreviousPage: boolean;
+            };
+            totalCount: number;
+        }>;
+        permissionSubjectDetail: (id: string, params?: RequestParams) => Promise<string>;
+        permissionSubjectCreate: (id: string, data: PermissionSubject, params?: RequestParams) => Promise<string>;
+        permissionSubjectUpdate: (id: string, data: PermissionSubject, params?: RequestParams) => Promise<string>;
+        permissionSubjectDelete: (id: string, params?: RequestParams) => Promise<boolean>;
+        referencesByPermissionDetail: (id: string, query: {
+            first: number;
+            after?: string;
+        }, params?: RequestParams) => Promise<{
+            edges: {
+                cursor: string;
+                node: {
+                    id: string;
+                    versionId: string;
+                    createdAt: string;
+                    readonly: boolean;
+                };
+            }[];
+            pageInfo: {
+                startCursor: string;
+                endCursor: string;
+                hasNextPage: boolean;
+                hasPreviousPage: boolean;
+            };
+            totalCount: number;
+        }>;
+    };
+    role: {
+        roleList: (query: {
+            first: number;
+            after?: string;
+        }, params?: RequestParams) => Promise<{
+            edges: {
+                cursor: string;
+                node: {
+                    id: string;
+                    versionId: string;
+                    createdAt: string;
+                    readonly: boolean;
+                };
+            }[];
+            pageInfo: {
+                startCursor: string;
+                endCursor: string;
+                hasNextPage: boolean;
+                hasPreviousPage: boolean;
+            };
+            totalCount: number;
+        }>;
+        roleDetail: (id: string, params?: RequestParams) => Promise<Role>;
+        roleCreate: (id: string, data: Role, params?: RequestParams) => Promise<Role>;
+        roleUpdate: (id: string, data: Role, params?: RequestParams) => Promise<Role>;
+        roleDelete: (id: string, params?: RequestParams) => Promise<boolean>;
+    };
+    roleLevel: {
+        roleLevelList: (query: {
+            first: number;
+            after?: string;
+        }, params?: RequestParams) => Promise<{
+            edges: {
+                cursor: string;
+                node: {
+                    id: string;
+                    versionId: string;
+                    createdAt: string;
+                    readonly: boolean;
+                };
+            }[];
+            pageInfo: {
+                startCursor: string;
+                endCursor: string;
+                hasNextPage: boolean;
+                hasPreviousPage: boolean;
+            };
+            totalCount: number;
+        }>;
+        roleLevelDetail: (id: string, params?: RequestParams) => Promise<string>;
+        roleLevelCreate: (id: string, data: RoleLevel, params?: RequestParams) => Promise<string>;
+        roleLevelUpdate: (id: string, data: RoleLevel, params?: RequestParams) => Promise<string>;
+        roleLevelDelete: (id: string, params?: RequestParams) => Promise<boolean>;
+        referencesByRoleDetail: (id: string, query: {
+            first: number;
+            after?: string;
+        }, params?: RequestParams) => Promise<{
+            edges: {
+                cursor: string;
+                node: {
+                    id: string;
+                    versionId: string;
+                    createdAt: string;
+                    readonly: boolean;
+                };
+            }[];
+            pageInfo: {
+                startCursor: string;
+                endCursor: string;
+                hasNextPage: boolean;
+                hasPreviousPage: boolean;
+            };
+            totalCount: number;
+        }>;
+    };
+}
+export {};

package/dist/prisma/seed/__generated__/seed.js

@@ -0,0 +1,390 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SeedApi = exports.HttpClient = exports.ContentType = void 0;
+var ContentType;
+(function (ContentType) {
+    ContentType["Json"] = "application/json";
+    ContentType["FormData"] = "multipart/form-data";
+    ContentType["UrlEncoded"] = "application/x-www-form-urlencoded";
+    ContentType["Text"] = "text/plain";
+})(ContentType || (exports.ContentType = ContentType = {}));
+class HttpClient {
+    constructor(apiConfig = {}) {
+        this.baseUrl = '/endpoint/restapi/revisium/seeding/master/draft';
+        this.securityData = null;
+        this.abortControllers = new Map();
+        this.customFetch = (...fetchParams) => fetch(...fetchParams);
+        this.baseApiParams = {
+            credentials: 'same-origin',
+            headers: {},
+            redirect: 'follow',
+            referrerPolicy: 'no-referrer',
+        };
+        this.setSecurityData = (data) => {
+            this.securityData = data;
+        };
+        this.contentFormatters = {
+            [ContentType.Json]: (input) => input !== null && (typeof input === 'object' || typeof input === 'string') ? JSON.stringify(input) : input,
+            [ContentType.Text]: (input) => (input !== null && typeof input !== 'string' ? JSON.stringify(input) : input),
+            [ContentType.FormData]: (input) => Object.keys(input || {}).reduce((formData, key) => {
+                const property = input[key];
+                formData.append(key, property instanceof Blob
+                    ? property
+                    : typeof property === 'object' && property !== null
+                        ? JSON.stringify(property)
+                        : `${property}`);
+                return formData;
+            }, new FormData()),
+            [ContentType.UrlEncoded]: (input) => this.toQueryString(input),
+        };
+        this.createAbortSignal = (cancelToken) => {
+            if (this.abortControllers.has(cancelToken)) {
+                const abortController = this.abortControllers.get(cancelToken);
+                if (abortController) {
+                    return abortController.signal;
+                }
+                return void 0;
+            }
+            const abortController = new AbortController();
+            this.abortControllers.set(cancelToken, abortController);
+            return abortController.signal;
+        };
+        this.abortRequest = (cancelToken) => {
+            const abortController = this.abortControllers.get(cancelToken);
+            if (abortController) {
+                abortController.abort();
+                this.abortControllers.delete(cancelToken);
+            }
+        };
+        this.request = async ({ body, secure, path, type, query, format, baseUrl, cancelToken, ...params }) => {
+            const secureParams = ((typeof secure === 'boolean' ? secure : this.baseApiParams.secure) &&
+                this.securityWorker &&
+                (await this.securityWorker(this.securityData))) ||
+                {};
+            const requestParams = this.mergeRequestParams(params, secureParams);
+            const queryString = query && this.toQueryString(query);
+            const payloadFormatter = this.contentFormatters[type || ContentType.Json];
+            const responseFormat = format || requestParams.format;
+            return this.customFetch(`${baseUrl || this.baseUrl || ''}${path}${queryString ? `?${queryString}` : ''}`, {
+                ...requestParams,
+                headers: {
+                    ...(requestParams.headers || {}),
+                    ...(type && type !== ContentType.FormData ? { 'Content-Type': type } : {}),
+                },
+                signal: (cancelToken ? this.createAbortSignal(cancelToken) : requestParams.signal) || null,
+                body: typeof body === 'undefined' || body === null ? null : payloadFormatter(body),
+            }).then(async (response) => {
+                const r = response.clone();
+                r.data = null;
+                r.error = null;
+                const data = !responseFormat
+                    ? r
+                    : await response[responseFormat]()
+                        .then((data) => {
+                        if (r.ok) {
+                            r.data = data;
+                        }
+                        else {
+                            r.error = data;
+                        }
+                        return r;
+                    })
+                        .catch((e) => {
+                        r.error = e;
+                        return r;
+                    });
+                if (cancelToken) {
+                    this.abortControllers.delete(cancelToken);
+                }
+                if (!response.ok)
+                    throw data;
+                return data.data;
+            });
+        };
+        Object.assign(this, apiConfig);
+    }
+    encodeQueryParam(key, value) {
+        const encodedKey = encodeURIComponent(key);
+        return `${encodedKey}=${encodeURIComponent(typeof value === 'number' ? value : `${value}`)}`;
+    }
+    addQueryParam(query, key) {
+        return this.encodeQueryParam(key, query[key]);
+    }
+    addArrayQueryParam(query, key) {
+        const value = query[key];
+        return value.map((v) => this.encodeQueryParam(key, v)).join('&');
+    }
+    toQueryString(rawQuery) {
+        const query = rawQuery || {};
+        const keys = Object.keys(query).filter((key) => 'undefined' !== typeof query[key]);
+        return keys
+            .map((key) => (Array.isArray(query[key]) ? this.addArrayQueryParam(query, key) : this.addQueryParam(query, key)))
+            .join('&');
+    }
+    addQueryParams(rawQuery) {
+        const queryString = this.toQueryString(rawQuery);
+        return queryString ? `?${queryString}` : '';
+    }
+    mergeRequestParams(params1, params2) {
+        return {
+            ...this.baseApiParams,
+            ...params1,
+            ...(params2 || {}),
+            headers: {
+                ...(this.baseApiParams.headers || {}),
+                ...(params1.headers || {}),
+                ...((params2 && params2.headers) || {}),
+            },
+        };
+    }
+}
+exports.HttpClient = HttpClient;
+class SeedApi extends HttpClient {
+    constructor() {
+        super(...arguments);
+        this.permission = {
+            permissionList: (query, params = {}) => this.request({
+                path: `/Permission`,
+                method: 'GET',
+                query: query,
+                secure: true,
+                format: 'json',
+                ...params,
+            }),
+            permissionDetail: (id, params = {}) => this.request({
+                path: `/Permission/${id}`,
+                method: 'GET',
+                secure: true,
+                format: 'json',
+                ...params,
+            }),
+            permissionCreate: (id, data, params = {}) => this.request({
+                path: `/Permission/${id}`,
+                method: 'POST',
+                body: data,
+                secure: true,
+                type: ContentType.Json,
+                format: 'json',
+                ...params,
+            }),
+            permissionUpdate: (id, data, params = {}) => this.request({
+                path: `/Permission/${id}`,
+                method: 'PUT',
+                body: data,
+                secure: true,
+                type: ContentType.Json,
+                format: 'json',
+                ...params,
+            }),
+            permissionDelete: (id, params = {}) => this.request({
+                path: `/Permission/${id}`,
+                method: 'DELETE',
+                secure: true,
+                format: 'json',
+                ...params,
+            }),
+            referencesByRoleDetail: (id, query, params = {}) => this.request({
+                path: `/Permission/${id}/references-by/Role`,
+                method: 'GET',
+                query: query,
+                secure: true,
+                format: 'json',
+                ...params,
+            }),
+        };
+        this.permissionAction = {
+            permissionActionList: (query, params = {}) => this.request({
+                path: `/PermissionAction`,
+                method: 'GET',
+                query: query,
+                secure: true,
+                format: 'json',
+                ...params,
+            }),
+            permissionActionDetail: (id, params = {}) => this.request({
+                path: `/PermissionAction/${id}`,
+                method: 'GET',
+                secure: true,
+                format: 'json',
+                ...params,
+            }),
+            permissionActionCreate: (id, data, params = {}) => this.request({
+                path: `/PermissionAction/${id}`,
+                method: 'POST',
+                body: data,
+                secure: true,
+                type: ContentType.Json,
+                format: 'json',
+                ...params,
+            }),
+            permissionActionUpdate: (id, data, params = {}) => this.request({
+                path: `/PermissionAction/${id}`,
+                method: 'PUT',
+                body: data,
+                secure: true,
+                type: ContentType.Json,
+                format: 'json',
+                ...params,
+            }),
+            permissionActionDelete: (id, params = {}) => this.request({
+                path: `/PermissionAction/${id}`,
+                method: 'DELETE',
+                secure: true,
+                format: 'json',
+                ...params,
+            }),
+            referencesByPermissionDetail: (id, query, params = {}) => this.request({
+                path: `/PermissionAction/${id}/references-by/Permission`,
+                method: 'GET',
+                query: query,
+                secure: true,
+                format: 'json',
+                ...params,
+            }),
+        };
+        this.permissionSubject = {
+            permissionSubjectList: (query, params = {}) => this.request({
+                path: `/PermissionSubject`,
+                method: 'GET',
+                query: query,
+                secure: true,
+                format: 'json',
+                ...params,
+            }),
+            permissionSubjectDetail: (id, params = {}) => this.request({
+                path: `/PermissionSubject/${id}`,
+                method: 'GET',
+                secure: true,
+                format: 'json',
+                ...params,
+            }),
+            permissionSubjectCreate: (id, data, params = {}) => this.request({
+                path: `/PermissionSubject/${id}`,
+                method: 'POST',
+                body: data,
+                secure: true,
+                type: ContentType.Json,
+                format: 'json',
+                ...params,
+            }),
+            permissionSubjectUpdate: (id, data, params = {}) => this.request({
+                path: `/PermissionSubject/${id}`,
+                method: 'PUT',
+                body: data,
+                secure: true,
+                type: ContentType.Json,
+                format: 'json',
+                ...params,
+            }),
+            permissionSubjectDelete: (id, params = {}) => this.request({
+                path: `/PermissionSubject/${id}`,
+                method: 'DELETE',
+                secure: true,
+                format: 'json',
+                ...params,
+            }),
+            referencesByPermissionDetail: (id, query, params = {}) => this.request({
+                path: `/PermissionSubject/${id}/references-by/Permission`,
+                method: 'GET',
+                query: query,
+                secure: true,
+                format: 'json',
+                ...params,
+            }),
+        };
+        this.role = {
+            roleList: (query, params = {}) => this.request({
+                path: `/Role`,
+                method: 'GET',
+                query: query,
+                secure: true,
+                format: 'json',
+                ...params,
+            }),
+            roleDetail: (id, params = {}) => this.request({
+                path: `/Role/${id}`,
+                method: 'GET',
+                secure: true,
+                format: 'json',
+                ...params,
+            }),
+            roleCreate: (id, data, params = {}) => this.request({
+                path: `/Role/${id}`,
+                method: 'POST',
+                body: data,
+                secure: true,
+                type: ContentType.Json,
+                format: 'json',
+                ...params,
+            }),
+            roleUpdate: (id, data, params = {}) => this.request({
+                path: `/Role/${id}`,
+                method: 'PUT',
+                body: data,
+                secure: true,
+                type: ContentType.Json,
+                format: 'json',
+                ...params,
+            }),
+            roleDelete: (id, params = {}) => this.request({
+                path: `/Role/${id}`,
+                method: 'DELETE',
+                secure: true,
+                format: 'json',
+                ...params,
+            }),
+        };
+        this.roleLevel = {
+            roleLevelList: (query, params = {}) => this.request({
+                path: `/RoleLevel`,
+                method: 'GET',
+                query: query,
+                secure: true,
+                format: 'json',
+                ...params,
+            }),
+            roleLevelDetail: (id, params = {}) => this.request({
+                path: `/RoleLevel/${id}`,
+                method: 'GET',
+                secure: true,
+                format: 'json',
+                ...params,
+            }),
+            roleLevelCreate: (id, data, params = {}) => this.request({
+                path: `/RoleLevel/${id}`,
+                method: 'POST',
+                body: data,
+                secure: true,
+                type: ContentType.Json,
+                format: 'json',
+                ...params,
+            }),
+            roleLevelUpdate: (id, data, params = {}) => this.request({
+                path: `/RoleLevel/${id}`,
+                method: 'PUT',
+                body: data,
+                secure: true,
+                type: ContentType.Json,
+                format: 'json',
+                ...params,
+            }),
+            roleLevelDelete: (id, params = {}) => this.request({
+                path: `/RoleLevel/${id}`,
+                method: 'DELETE',
+                secure: true,
+                format: 'json',
+                ...params,
+            }),
+            referencesByRoleDetail: (id, query, params = {}) => this.request({
+                path: `/RoleLevel/${id}/references-by/Role`,
+                method: 'GET',
+                query: query,
+                secure: true,
+                format: 'json',
+                ...params,
+            }),
+        };
+    }
+}
+exports.SeedApi = SeedApi;
+//# sourceMappingURL=seed.js.map