@edraj/tsdmart 1.0.0

package/.idea/modules.xml

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectModuleManager">
+    <modules>
+      <module fileurl="file://$PROJECT_DIR$/.idea/tsdmart.iml" filepath="$PROJECT_DIR$/.idea/tsdmart.iml" />
+    </modules>
+  </component>
+</project>

package/.idea/tsdmart.iml

@@ -0,0 +1,13 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="WEB_MODULE" version="4">
+  <component name="NewModuleRootManager">
+    <content url="file://$MODULE_DIR$">
+      <excludeFolder url="file://$MODULE_DIR$/.tmp" />
+      <excludeFolder url="file://$MODULE_DIR$/temp" />
+      <excludeFolder url="file://$MODULE_DIR$/tmp" />
+      <excludeFolder url="file://$MODULE_DIR$/b" />
+    </content>
+    <orderEntry type="inheritedJdk" />
+    <orderEntry type="sourceFolder" forTests="false" />
+  </component>
+</module>

package/.idea/vcs.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="VcsDirectoryMappings">
+    <mapping directory="" vcs="Git" />
+  </component>
+</project>

package/CHANGELOG.md

@@ -0,0 +1,3 @@
+## 1.0.0
+
+- Initial version.

package/LICENSE

@@ -0,0 +1,11 @@
+Copyright © 2024 Kefah T. Issa
+
+Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS “AS IS” AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

package/README.md

@@ -0,0 +1,29 @@
+# Dmart
+
+A TypeScript implementation of the Dmart that depends on axios.
+
+## APIs 
+
+* `login(shortname: string, password: string) -> Promise<ApiResponse>` - Performs a login action.
+* `logout() -> Promise<ApiResponse>` - Performs a logout action.
+* `create_user(request: any) -> Promise<ActionResponse>` - Creates a new user.
+* `update_user(request: any) -> Promise<ActionResponse>` - Updates an existing user.
+* `check_existing(prop: string, value: string) -> Promise<ResponseEntry | null>` - Checks if a user exists.
+* `get_profile() -> Promise<ProfileResponse | null>` - Gets the profile of the current user.
+* `query(query: QueryRequest) -> Promise<ApiQueryResponse | null>` - Performs a query action.
+* `csv(query: any) -> Promise<ApiQueryResponse>` - Query the entries as csv file.
+* `space(action: ActionRequest) -> Promise<ActionResponse>` - Performs actions on spaces.
+* `request(action: ActionRequest) -> Promise<ActionResponse>` - Performs a request action.
+* `retrieve_entry(resource_type: ResourceType, space_name: string, subpath: string, shortname: string, retrieve_json_payload: boolean = false, retrieve_attachments: boolean = false, validate_schema: boolean = true) -> Promise<ResponseEntry|null>` - Performs a retrieve action.
+* `upload_with_payload(space_name: string, subpath: string, shortname: string, resource_type: ResourceType, payload_file: File, content_type?: ContentType, schema_shortname?: string) -> Promise<ApiResponse>` - Uploads a file with a payload.
+* `fetchDataAsset(resourceType: string, dataAssetType: string, spaceName: string, subpath: string, shortname: string, query_string?: string, filter_data_assets?: string[], branch_name?: string) -> Promise<any>` - Fetches a data asset.
+* `get_spaces() -> Promise<ApiResponse | null>` - Gets the spaces (user query).
+* `get_children(space_name: string, subpath: string, limit: number = 20, offset: number = 0, restrict_types: Array<ResourceType> = []) -> Promise<ApiResponse | null>` - Gets the children of a space (user query).
+* `get_attachment_url(resource_type: ResourceType, space_name: string, subpath: string, parent_shortname: string, shortname: string, ext: string) -> string` - Constructs the URL of an attachment.
+* `get_space_health(space_name: string) -> Promise<ApiQueryResponse & { attributes: { folders_report: Object } }>` - Gets the health check of a space.
+* `get_attachment_content(resource_type: string, space_name: string, subpath: string, shortname: string) -> Promise<any>` - Gets the content of an attachment.
+* `get_payload(resource_type: string, space_name: string, subpath: string, shortname: string, ext: string = ".json") -> Promise<any>` - Gets the payload of a resource.
+* `get_payload_content(resource_type: string, space_name: string, subpath: string, shortname: string, ext: string = ".json") -> Promise<any>` - Gets the content of a payload.
+* `progress_ticket(space_name: string, subpath: string, shortname: string, action: string, resolution?: string, comment?: string) -> Promise<ApiQueryResponse & { attributes: { folders_report: Object } }>` - Performs a progress ticket action.
+* `get_manifest() -> Promise<any>` - Gets the manifest of the current instance.
+* `get_settings() -> Promise<any>` - Gets the settings of the current instance.

package/b/axios.js

@@ -0,0 +1,9 @@
+// @ts-nocheck
+// import axios from 'axios';
+var postData = {
+    password: 'Password1234',
+    shortname: 'dmart'
+};
+var url = 'https://dmart.cc/dmart/user/login'; // Example endpoint
+var response = await axios.post(url, postData);
+console.log(response.data);

package/b/axios.ts

@@ -0,0 +1,36 @@
+// @ts-nocheck
+import axios from 'axios';
+
+let response = await axios.post('https://dmart.cc/dmart/user/login', {
+    password: 'Password1234',
+    shortname: 'dmart'
+});
+
+let config = {
+    method: 'post',
+    maxBodyLength: Infinity,
+    url: 'https://dmart.cc/dmart/managed/query',
+    headers: {
+        'Content-Type': 'application/json',
+        'Authorization': 'Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJkYXRhIjp7InVzZXJuYW1lIjoiamltbXkifSwiZXhwaXJlcyI6MTcxMzI2ODQ3Ni43NDEzMjR9.pEmHFJFv1x43WGIhKNfSL5PVr2zI06yeOQv7QGojtQk'
+    },
+    data: JSON.stringify({
+        "type": "subpath",
+        "space_name": "management",
+        "subpath": "users",
+        "sort_by": "created_at",
+        "sort_type": "ascending",
+        "retrieve_json_payload": true
+    })
+};
+
+
+// for (let i = 0; i < 100; i++) {
+//     await axios.request(config);
+// }
+
+const requests = [];
+for (let i = 0; i < 1000; i++) {
+    requests.push(axios.request(config));
+}
+await Promise.all(requests);

package/b/http.ts

@@ -0,0 +1,76 @@
+import https from 'https';
+
+// Function to make a POST request
+function makePostRequest(url: any, data: any, headers: any) {
+    return new Promise((resolve, reject) => {
+        const options = {
+            method: 'POST',
+            headers: {
+                ...headers,
+                'Content-Type': 'application/json'
+            }
+        };
+
+        const req = https.request(url, options, (res) => {
+            let responseData = '';
+            res.on('data', (chunk) => {
+                responseData += chunk;
+            });
+
+            res.on('end', () => {
+                resolve(responseData);
+            });
+        });
+
+        req.on('error', (error) => {
+            reject(error);
+        });
+
+        req.write(JSON.stringify(data));
+        req.end();
+    });
+}
+
+// Main logic
+async function main() {
+    // Login request
+    let loginResponse: any = await makePostRequest('https://dmart.cc/dmart/user/login', {
+        password: 'Password1234',
+        shortname: 'dmart'
+    }, {});
+    const token = JSON.parse(loginResponse).records[0].attributes.access_token;
+    // Use the login response to generate the authorization header
+    let authHeader = `Bearer ${token}`;
+
+    // Request config
+    let config = {
+        method: 'post',
+        maxBodyLength: Infinity,
+        url: 'https://dmart.cc/dmart/managed/query',
+        headers: {
+            'Authorization': authHeader,
+            'Content-Type': 'application/json'
+        },
+        data: {
+            "type": "subpath",
+            "space_name": "management",
+            "subpath": "users",
+            "sort_by": "created_at",
+            "sort_type": "ascending",
+            "retrieve_json_payload": true
+        }
+    };
+
+    // Making 100 requests
+    // for (let i = 0; i < 100; i++) {
+    //     await makePostRequest(config.url, config.data, config.headers);
+    // }
+    const requests = [];
+    for (let i = 0; i < 500; i++) {
+        requests.push(makePostRequest(config.url, config.data, config.headers));
+    }
+    await Promise.all(requests);
+}
+
+// Call main function
+main();

package/dmart.ts

@@ -0,0 +1,712 @@
+import axios from "axios";
+
+let baseURL = "http://localhost:8282";
+
+axios.defaults.withCredentials = true;
+
+export enum Status {
+    success = "success",
+    failed = "failed",
+}
+
+type Error = {
+    type: string;
+    code: number;
+    message: string;
+    info: any;
+};
+
+export type ApiResponseRecord = {
+    resource_type: string;
+    shortname: string;
+    branch_name?: string;
+    subpath: string;
+    attributes: Record<string, any>;
+};
+
+export type ApiResponse = {
+    status: Status;
+    error?: Error;
+    records: Array<ApiResponseRecord>;
+};
+
+type Translation = {
+    ar: string;
+    en: string;
+    kd: string;
+};
+
+enum UserType {
+    web = "web",
+    mobile = "mobile",
+    bot = "bot",
+}
+
+type LoginResponseRecord = ApiResponseRecord & {
+    attributes: {
+        access_token: string;
+        type: UserType;
+        displayname: Translation;
+    };
+};
+
+// type LoginResponse = ApiResponse  & { records : Array<LoginResponseRecord> };
+
+type Permission = {
+    allowed_actions: Array<ActionType>;
+    conditions: Array<string>;
+    restricted_fields: Array<any>;
+    allowed_fields_values: Map<string, any>;
+};
+
+enum Language {
+    arabic = "arabic",
+    english = "engligh",
+    kurdish = "kurdish",
+    french = "french",
+    turkish = "turkish",
+}
+
+type ProfileResponseRecord = ApiResponseRecord & {
+    attributes: {
+        email: string;
+        displayname: Translation;
+        type: string;
+        language: Language;
+        is_email_verified: boolean;
+        is_msisdn_verified: boolean;
+        force_password_change: boolean;
+        permissions: Record<string, Permission>;
+    };
+};
+
+export enum ActionType {
+    query = "query",
+    view = "view",
+    update = "update",
+    create = "create",
+    delete = "delete",
+    attach = "attach",
+    move = "move",
+    progress_ticket = "progress_ticket",
+}
+
+export type ProfileResponse = ApiResponse & {
+    records: Array<ProfileResponseRecord>;
+};
+
+let headers: { [key: string]: string } = {
+    "Content-type": "application/json",
+    //"Authorization": ""
+};
+
+export type AggregationReducer = {
+    name: string;
+    alias: string;
+    args: Array<string>;
+};
+
+export type AggregationType = {
+    load: Array<string>;
+    group_by: Array<string>;
+    reducers: Array<AggregationReducer> | Array<string>;
+};
+
+export enum QueryType {
+    aggregation = "aggregation",
+    search = "search",
+    subpath = "subpath",
+    events = "events",
+    history = "history",
+    tags = "tags",
+    spaces = "spaces",
+    counters = "counters",
+    reports = "reports",
+}
+
+export enum SortyType {
+    ascending = "ascending",
+    descending = "descending",
+}
+
+// enum NotificationPriority {
+//   high = "high",
+//   medium = "medium",
+//   low = "low"
+// };
+
+export type QueryRequest = {
+    type: QueryType;
+    space_name: string;
+    subpath: string;
+    filter_types?: Array<ResourceType>;
+    filter_schema_names?: Array<string>;
+    filter_shortnames?: Array<string>;
+    search: string;
+    from_date?: string;
+    to_date?: string;
+    sort_by?: string;
+    sort_type?: SortyType;
+    retrieve_json_payload?: boolean;
+    retrieve_attachments?: boolean;
+    validate_schema?: boolean;
+    jq_filter?: string;
+    exact_subpath?: boolean;
+    limit?: number;
+    offset?: number;
+    aggregation_data?: AggregationType;
+};
+
+export enum RequestType {
+    create = "create",
+    update = "update",
+    replace = "replace",
+    delete = "delete",
+    move = "move",
+}
+
+export enum ResourceAttachmentType {
+    json = "json",
+    comment = "comment",
+    media = "media",
+    relationship = "relationship",
+    alteration = "alteration",
+    csv = "csv",
+    parquet = "parquet",
+    jsonl = "jsonl",
+    sqlite = "sqlite",
+}
+
+export enum ResourceType {
+    user = "user",
+    group = "group",
+    folder = "folder",
+    schema = "schema",
+    content = "content",
+    acl = "acl",
+    comment = "comment",
+    media = "media",
+    locator = "locator",
+    relationship = "relationship",
+    alteration = "alteration",
+    history = "history",
+    space = "space",
+    branch = "branch",
+    permission = "permission",
+    role = "role",
+    ticket = "ticket",
+    json = "json",
+    post = "post",
+    plugin_wrapper = "plugin_wrapper",
+    notification = "notification",
+    jsonl = "jsonl",
+    csv = "csv",
+    sqlite = "sqlite",
+    parquet = "parquet",
+}
+
+export enum ContentType {
+    text = "text",
+    html = "html",
+    markdown = "markdown",
+    json = "json",
+    image = "image",
+    python = "python",
+    pdf = "pdf",
+    audio = "audio",
+    video = "video",
+    jsonl = "jsonl",
+    csv = "csv",
+    sqlite = "sqlite",
+    parquet = "parquet",
+}
+export enum ContentTypeMedia {
+    text = "text",
+    html = "html",
+    markdown = "markdown",
+    image = "image",
+    python = "python",
+    pdf = "pdf",
+    audio = "audio",
+    video = "video",
+}
+
+type Payload = {
+    content_type: ContentType;
+    schema_shortname?: string;
+    checksum: string;
+    body: string | Record<string, any> | any;
+    last_validated: string;
+    validation_status: "valid" | "invalid";
+};
+
+type MetaExtended = {
+    email: string;
+    msisdn: string;
+    is_email_verified: boolean;
+    is_msisdn_verified: boolean;
+    force_password_change: boolean;
+    password: string;
+    workflow_shortname: string;
+    state: string;
+    is_open: boolean;
+};
+
+export type ResponseEntry = MetaExtended & {
+    uuid: string;
+    shortname: string;
+    subpath: string;
+    is_active: boolean;
+    displayname: Translation;
+    description: Translation;
+    tags: Set<string>;
+    created_at: string;
+    updated_at: string;
+    owner_shortname: string;
+    payload?: Payload;
+    relationships?: any;
+    attachments?: Object;
+    workflow_shortname?: string;
+    state?: string;
+};
+
+export type ResponseRecord = {
+    resource_type: ResourceType;
+    uuid: string;
+    shortname: string;
+    subpath: string;
+    attributes: {
+        is_active: boolean;
+        displayname: Translation;
+        description: Translation;
+        tags: Set<string>;
+        created_at: string;
+        updated_at: string;
+        owner_shortname: string;
+        payload?: Payload;
+    };
+};
+
+export type ActionResponse = ApiResponse & {
+    records: Array<
+        ResponseRecord & {
+        attachments: {
+            media: Array<ResponseRecord>;
+            json: Array<ResponseRecord>;
+        };
+    }
+    >;
+};
+
+type ActionRequestRecord = {
+    resource_type: ResourceType;
+    uuid?: string;
+    shortname: string;
+    subpath: string;
+    attributes: Record<string, any>;
+    attachments?: Record<ResourceType, Array<any>>;
+};
+
+export type ActionRequest = {
+    space_name: string;
+    request_type: RequestType;
+    records: Array<ActionRequestRecord>;
+};
+
+
+type ApiQueryResponse = ApiResponse & {
+    attributes: { total: number; returned: number };
+};
+
+export class Dmart {
+
+    public async login(shortname: string, password: string) {
+        const { data } = await axios.post<
+            ApiResponse & { records: Array<LoginResponseRecord> }
+        >(baseURL + "/user/login", { shortname, password }, { headers });
+        //console.log(JSON.stringify(data, null, 2));
+        // FIXME settins Authorization is only needed when the code is running on the server
+        /*headers.Authorization = "";
+        if (data.status == Status.success && data.records.length > 0) {
+          headers.Authorization = "Bearer " + data.records[0].attributes.access_token;
+        }*/
+        return data;
+    }
+
+     public async logout() {
+        const { data } = await axios.post<ApiResponse>(
+            baseURL + "/user/logout",
+            {},
+            { headers }
+        );
+        return data;
+    }
+
+    public async create_user(request: any) {
+        try {
+            const { data } = await axios.post<ActionResponse>(
+                baseURL + "/user/create",
+                request,
+                { headers }
+            );
+            return data;
+        } catch (error: any) {
+            return error.response.data;
+        }
+    }
+
+    public async update_user(request: any) {
+        try {
+            const { data } = await axios.post<ActionResponse>(
+                baseURL + "/user/profile",
+                request,
+                { headers }
+            );
+            return data;
+        } catch (error: any) {
+            return error.response.data;
+        }
+    }
+
+    public async check_existing(prop: string, value: string) {
+        try {
+            const { data } = await axios.get<ResponseEntry>(
+                baseURL +
+                `/user/check-existing?${prop}=${value}`,
+                { headers }
+            );
+            return data;
+        } catch (error: any) {
+            return null;
+        }
+    }
+
+    public async get_profile() {
+        try {
+            const { data } = await axios.get<ProfileResponse>(
+                baseURL + "/user/profile",
+                {
+                    headers,
+                }
+            );
+            if (typeof localStorage !== "undefined" && data.status === "success") {
+                localStorage.setItem(
+                    "permissions",
+                    JSON.stringify((data?.records ?? [{}])[0]?.attributes.permissions)
+                );
+                localStorage.setItem(
+                    "roles",
+                    JSON.stringify((data?.records ?? [{}])[0]?.attributes?.["roles"])
+                );
+            }
+            return data;
+        } catch (error: any) {
+            return null;
+        }
+    }
+
+    public async query(query: QueryRequest): Promise<ApiQueryResponse|null> {
+        try {
+            if (query.type != QueryType.spaces) {
+                query.sort_type = query.sort_type || SortyType.ascending;
+                query.sort_by = query.sort_by || "created_at";
+            }
+            query.subpath = query.subpath.replace(/\/+/g, "/");
+            const { data } = await axios.post<ApiQueryResponse>(
+                baseURL + "/managed/query",
+                query,
+                { headers , timeout: 3000 }
+            );
+            return data;
+        } catch (e) {
+            return null;
+        }
+    }
+
+    public async csv(query: any): Promise<ApiQueryResponse> {
+        try {
+            query.sort_type = query.sort_type || SortyType.ascending;
+            query.sort_by = "created_at";
+            query.subpath = query.subpath.replace(/\/+/g, "/");
+            const { data } = await axios.post<ApiQueryResponse>(
+                baseURL + "/managed/csv",
+                query,
+                { headers }
+            );
+            return data;
+        } catch (error: any) {
+            return error.response.data;
+        }
+    }
+
+    public async space(action: ActionRequest): Promise<ActionResponse> {
+        try {
+            const { data } = await axios.post<ActionResponse>(
+                baseURL + "/managed/space",
+                action,
+                { headers }
+            );
+            return data;
+        } catch (error: any) {
+            return error.response.data;
+        }
+    }
+
+    public async request(action: ActionRequest): Promise<ActionResponse> {
+        try {
+            const { data } = await axios.post<ActionResponse>(
+                baseURL + "/managed/request",
+                action,
+                { headers }
+            );
+            return data;
+        } catch (error: any) {
+            return error.response.data;
+        }
+    }
+
+    public async retrieve_entry(
+        resource_type: ResourceType,
+        space_name: string,
+        subpath: string,
+        shortname: string,
+        retrieve_json_payload: boolean = false,
+        retrieve_attachments: boolean = false,
+        validate_schema: boolean = true
+    ): Promise<ResponseEntry|null> {
+        try {
+            if (!subpath || subpath == "/") subpath = "__root__";
+            const { data } = await axios.get<ResponseEntry>(
+                baseURL +
+                `/managed/entry/${resource_type}/${space_name}/${subpath}/${shortname}?retrieve_json_payload=${retrieve_json_payload}&retrieve_attachments=${retrieve_attachments}&validate_schema=${validate_schema}`.replace(
+                    /\/+/g,
+                    "/"
+                ),
+                { headers }
+            );
+            return data;
+        } catch (error: any) {
+            throw new Error(error.response.data.error.message)
+        }
+    }
+
+    public async upload_with_payload(
+        space_name: string,
+        subpath: string,
+        shortname: string,
+        resource_type: ResourceType,
+        payload_file: File,
+        content_type?: ContentType,
+        schema_shortname?: string
+    ): Promise<ApiResponse> {
+        const request_record_body:any = {
+            resource_type,
+            subpath,
+            shortname,
+            attributes: { is_active: true, payload: {body:{}} },
+        };
+        if (content_type){
+            request_record_body.attributes.payload.content_type = content_type;
+        }
+        if (schema_shortname){
+            request_record_body.attributes.payload.schema_shortname = schema_shortname;
+        }
+
+        const request_record = new Blob(
+            [
+                JSON.stringify(request_record_body),
+            ],
+            { type: "application/json" }
+        );
+
+        const form_data = new FormData();
+        form_data.append("space_name", space_name);
+        form_data.append("request_record", request_record);
+        form_data.append("payload_file", payload_file);
+
+        const headers = { "Content-Type": "multipart/form-data" };
+
+        const { data } = await axios.post<ApiResponse>(
+            baseURL + "/managed/resource_with_payload",
+            form_data,
+            { headers }
+        );
+
+        return data;
+    }
+
+
+    public async fetchDataAsset(
+        resourceType: string,  // Replace with actual type if needed
+        dataAssetType: string,  // Replace with actual type if needed
+        spaceName: string,
+        subpath: string,
+        shortname: string,
+        query_string?: string,
+        filter_data_assets?: string[],
+        branch_name?: string
+    ) {
+        try {
+            const endpoint = "/managed/data-asset";
+            const url = `${baseURL}${endpoint}`;
+            const { data } = await axios.post(
+                url,
+                {
+                    space_name: spaceName,
+                    resource_type: resourceType,
+                    data_asset_type: dataAssetType,
+                    subpath,
+                    shortname,
+                    query_string: query_string ?? "SELECT * FROM file",
+                    filter_data_assets,
+                    branch_name,
+                },
+                { headers }
+            );
+
+            return data;
+        } catch (error: any) {
+            return error;
+        }
+    }
+
+    public async get_spaces(): Promise<ApiResponse | null> {
+        return await this.query({
+            type: QueryType.spaces,
+            space_name: "management",
+            subpath: "/",
+            search: "",
+            limit: 100,
+        });
+    }
+
+    public async get_children(
+        space_name: string,
+        subpath: string,
+        limit: number = 20,
+        offset: number = 0,
+        restrict_types: Array<ResourceType> = []
+    ): Promise<ApiResponse | null> {
+        return await this.query({
+            type: QueryType.search,
+            space_name: space_name,
+            subpath: subpath,
+            filter_types: restrict_types,
+            exact_subpath: true,
+            search: "",
+            limit: limit,
+            offset: offset,
+        });
+    }
+
+    public get_attachment_url(
+        resource_type: ResourceType,
+        space_name: string,
+        subpath: string,
+        parent_shortname: string,
+        shortname: string,
+        ext: string
+    ) {
+        return (
+            baseURL +
+            `/managed/payload/${resource_type}/${space_name}/${subpath.replace(
+                /\/+$/,
+                ""
+            )}/${parent_shortname}/${shortname}.${ext}`.replaceAll("..", ".")
+        );
+    }
+
+    public async get_space_health(space_name: string) {
+        const { data } = await axios.get<
+            ApiQueryResponse & { attributes: { folders_report: Object } }
+        >(baseURL + `/managed/health/${space_name}`, { headers });
+        return data;
+    }
+
+    public async get_attachment_content(
+        resource_type: string,
+        space_name: string,
+        subpath: string,
+        shortname: string,
+    ) {
+        const { data } = await axios.get<any>(
+            baseURL +
+            `/managed/payload/${resource_type}/${space_name}/${subpath}/${shortname}`,
+            { headers }
+        );
+        return data;
+    }
+    public async get_payload(
+        resource_type: string,
+        space_name: string,
+        subpath: string,
+        shortname: string,
+        ext: string = ".json"
+    ) {
+        const { data } = await axios.get<any>(
+            baseURL +
+            `/managed/payload/${resource_type}/${space_name}/${subpath}/${shortname}${ext}`,
+            { headers }
+        );
+        return data;
+    }
+    public async get_payload_content(
+        resource_type: string,
+        space_name: string,
+        subpath: string,
+        shortname: string,
+        ext: string = ".json"
+    ) {
+        const { data } = await axios.get<any>(
+            baseURL +
+            `/managed/payload/${resource_type}/${space_name}/${subpath}/${shortname}${ext}`,
+            { headers }
+        );
+        return data;
+    }
+
+    public async progress_ticket(
+        space_name: string,
+        subpath: string,
+        shortname: string,
+        action: string,
+        resolution?: string,
+        comment?: string
+    ) {
+        try {
+            const payload: any = {}
+            if(resolution){
+                payload.resolution = resolution;
+            }
+            if(comment){
+                payload.comment = comment;
+            }
+            const { data } = await axios.put<
+                ApiQueryResponse & { attributes: { folders_report: Object } }
+            >(
+                baseURL +
+                `/managed/progress-ticket/${space_name}/${subpath}/${shortname}/${action}`,
+                payload,
+                { headers }
+            );
+            return data;
+        } catch (error: any) {
+            return error.response.data;
+        }
+    }
+
+    public async get_manifest() {
+        const { data } = await axios.get<any>(baseURL + `/info/manifest`, {
+            headers,
+        });
+        return data;
+    }
+
+    public async get_settings() {
+        const { data } = await axios.get<any>(baseURL + `/info/settings`, {
+            headers,
+        });
+        return data;
+    }
+}
+// 23 funcs

package/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "@edraj/tsdmart",
+  "version": "1.0.0",
+  "description": "A TypeScript implementation of the Dmart that depends on axios.",
+  "author": "Kefah T. Issa",
+  "email": "kefah.issa@gmail.com",
+  "license": "AGPL-3.0-or-later",
+  "main": "index.ts",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "type": "module",
+  "devDependencies": {
+    "@types/node": "^20.11.28",
+    "@typescript-eslint/eslint-plugin": "^7.2.0",
+    "@typescript-eslint/parser": "^7.2.0",
+    "eslint": "^8.57.0",
+    "ts-node": "^10.9.2",
+    "tsconfig-paths": "^4.2.0",
+    "tslib": "^2.6.2",
+    "typescript": "^5.4.2"
+  },
+  "dependencies": {
+    "axios": "^1.6.8"
+  }
+}

package/tsconfig.json

@@ -0,0 +1,47 @@
+{
+    "compilerOptions": {
+        "module": "ESNext",
+        "moduleResolution": "Node",
+        "target": "ESNext",
+        "esModuleInterop": true,
+        // Strict Checks
+        "alwaysStrict": true,
+        "noImplicitAny": true,
+        "strictNullChecks": true,
+        "useUnknownInCatchVariables": true,
+        "strictPropertyInitialization": true,
+        "strictFunctionTypes": true,
+        "noImplicitThis": true,
+        "strictBindCallApply": true,
+        "noPropertyAccessFromIndexSignature": true,
+        "noUncheckedIndexedAccess": true,
+        "exactOptionalPropertyTypes": true,
+        // Linter Checks
+        "noImplicitReturns": true,
+        "noImplicitOverride": true,
+        "forceConsistentCasingInFileNames": true,
+        // https://eslint.org/docs/rules/consistent-return ?
+        "noFallthroughCasesInSwitch": true,
+        // https://eslint.org/docs/rules/no-fallthrough
+        "noUnusedLocals": true,
+        // https://eslint.org/docs/rules/no-unused-vars
+        "noUnusedParameters": true,
+        // https://eslint.org/docs/rules/no-unused-vars#args
+        "allowUnreachableCode": false,
+        // https://eslint.org/docs/rules/no-unreachable ?
+        "allowUnusedLabels": false,
+        // https://eslint.org/docs/rules/no-unused-labels
+        // Base Strict Checks
+        "noImplicitUseStrict": false,
+        "suppressExcessPropertyErrors": false,
+        "suppressImplicitAnyIndexErrors": false,
+        "noStrictGenericChecks": false,
+    },
+    "ts-node": {
+        "esm": true
+    },
+    "parser": "@typescript-eslint/parser",
+    "plugins": [
+        "@typescript-eslint"
+    ]
+}