@lobb-js/studio 0.1.31 → 0.1.32

package/src/lib/Lobb.ts

@@ -1,241 +0,0 @@
-import qs from "qs";
-import { parseFunction } from "./utils";
-
-interface RouteParams {
-    method: string;
-    route: string;
-    payload?: any;
-}
-
-type OnResponseHandlers = (reponse: Response) => void;
-
-export class Lobb {
-    public lobbUrl: string;
-    private headers: HeadersInit = [];
-    private onResponseHandlers: Array<OnResponseHandlers> = [];
-
-    constructor(lobbUrl: string) {
-        this.lobbUrl = lobbUrl;
-    }
-
-    public async onResponse(callback: OnResponseHandlers) {
-        this.onResponseHandlers.push(callback);
-    }
-
-    public setHeaders(headers: HeadersInit) {
-        this.headers = headers;
-    }
-
-    public getHeaders() {
-        return this.headers;
-    }
-
-    public async getMeta() {
-        const response = await fetch(`${this.lobbUrl}/api/meta`, {
-            headers: this.headers,
-        });
-
-        const metaResponse = await this.handleResponse(response);
-        const meta = await metaResponse.json();
-
-        meta.studio_workflows = meta.studio_workflows.map((workflow: any) => {
-            return {
-                ...workflow,
-                handler: parseFunction(workflow.handler),
-            };
-        });
-
-        return meta;
-    }
-
-    // CRUD methods
-    public async findAll(collectionName: string, params: any) {
-        const response = await fetch(
-            `${this.lobbUrl}/api/collections/${collectionName}/search`,
-            {
-                method: "POST",
-                headers: this.headers,
-                body: JSON.stringify(params),
-            },
-        );
-        return await this.handleResponse(response);
-    }
-
-    public async findOne(
-        collectionName: string,
-        id: string,
-        queryParams?: any,
-    ) {
-        queryParams = queryParams ? `?${qs.stringify(queryParams)}` : "";
-        const response = await fetch(
-            `${this.lobbUrl}/api/collections/${collectionName}/${id}${queryParams}`,
-            {
-                method: "GET",
-                headers: this.headers,
-            },
-        );
-        return await this.handleResponse(response);
-    }
-
-    public async createOne(collectionName: string, body: any, file?: File) {
-        if (file) {
-            const formData = new FormData();
-            Object.keys(body).forEach((key) => {
-                formData.append(key, body[key]);
-            });
-            formData.append("file", file, file.name);
-            formData.append(
-                "payload",
-                JSON.stringify({
-                    data: body,
-                }),
-            );
-            body = formData;
-        } else {
-            body = JSON.stringify({
-                data: body,
-            });
-        }
-        const response = await fetch(
-            `${this.lobbUrl}/api/collections/${collectionName}`,
-            {
-                method: "POST",
-                headers: this.headers,
-                body,
-            },
-        );
-        return await this.handleResponse(response);
-    }
-
-    public async updateOne(collectionName: string, id: string, body: any) {
-        const response = await fetch(
-            `${this.lobbUrl}/api/collections/${collectionName}/${id}`,
-            {
-                method: "PATCH",
-                headers: this.headers,
-                body: JSON.stringify({
-                    data: body,
-                }),
-            },
-        );
-        return await this.handleResponse(response);
-    }
-
-    public async readSingleton(
-        collectionName: string,
-    ) {
-        const response = await fetch(
-            `${this.lobbUrl}/api/collections/${collectionName}/singleton`,
-            {
-                method: "GET",
-                headers: this.headers,
-            },
-        );
-        return await this.handleResponse(response);
-    }
-
-    public async updateSingleton(
-        collectionName: string,
-        body: Record<string, any>
-    ) {
-        const response = await fetch(
-            `${this.lobbUrl}/api/collections/${collectionName}/singleton`,
-            {
-                method: "PATCH",
-                headers: this.headers,
-                body: JSON.stringify({
-                    data: body,
-                }),
-            },
-        );
-        return await this.handleResponse(response);
-    }
-
-    public async deleteOne(collectionName: string, id: string, force = false) {
-        const response = await fetch(
-            `${this.lobbUrl}/api/collections/${collectionName}/${id}${force ? "?force" : ""}`,
-            {
-                method: "DELETE",
-                headers: this.headers,
-            },
-        );
-        return await this.handleResponse(response);
-    }
-
-    public async deleteMany(collectionName: string, filter: any, force = false) {
-        const response = await fetch(
-            `${this.lobbUrl}/api/collections/${collectionName}${force ? "?force" : ""}`,
-            {
-                method: "DELETE",
-                headers: this.headers,
-                body: JSON.stringify({
-                    filter,
-                }),
-            },
-        );
-        return await this.handleResponse(response);
-    }
-
-    public async createMany(collectionName: string, body: any) {
-        body = JSON.stringify({
-            data: body,
-        });
-        const response = await fetch(
-            `${this.lobbUrl}/api/collections/${collectionName}`,
-            {
-                method: "POST",
-                headers: this.headers,
-                body,
-            },
-        );
-        return await this.handleResponse(response);
-    }
-
-    public async updateMany(collectionName: string, body: any, filter: any) {
-        const response = await fetch(
-            `${this.lobbUrl}/api/collections/${collectionName}`,
-            {
-                method: "PATCH",
-                headers: this.headers,
-                body: JSON.stringify({
-                    filter,
-                    data: body,
-                }),
-            },
-        );
-        return await this.handleResponse(response);
-    }
-
-    public async transactions(body: any[], rollback?: boolean) {
-        const response = await fetch(
-            `${this.lobbUrl}/api/collections/transactions${
-                rollback ? "?rollback" : ""
-            }`,
-            {
-                method: "POST",
-                headers: this.headers,
-                body: JSON.stringify(body),
-            },
-        );
-        return await this.handleResponse(response);
-    }
-
-    // CUSTOM REQUEST methods
-    public async request(params: RouteParams) {
-        const response = await fetch(`${this.lobbUrl}${params.route}`, {
-            method: params.method,
-            headers: this.headers,
-            body: JSON.stringify(params.payload),
-        });
-        return await this.handleResponse(response);
-    }
-
-    // HELPER methods
-    private async handleResponse(response: Response): Promise<Response> {
-        for (let index = 0; index < this.onResponseHandlers.length; index++) {
-            const handler = this.onResponseHandlers[index];
-            handler(response.clone());
-        }
-        return response;
-    }
-}

package/src/lib/components/confirmationDialog/store.svelte.ts

@@ -1,28 +0,0 @@
-import { mount, unmount } from "svelte";
-import ConfirmationDialog from "./confirmationDialog.svelte";
-
-export function showDialog(title: string, description: string): Promise<boolean> {
-    return new Promise((resolve) => {
-        const targetElement = document.querySelector('main');
-
-        if (!targetElement) {
-            throw new Error("main html element doesn't exist for some reason");
-        }
-
-        const mountedElement = mount(ConfirmationDialog, {
-            target: targetElement,
-            props: {
-                title,
-                description,
-                onDecision: async (result: boolean) => {
-                    resolve(result);
-                    await unmount(mountedElement, {
-                        outro: true
-                    });
-                }
-            },
-        });
-
-        console.log("the dialog is mounted man")
-    });
-}

package/src/lib/components/dataTable/utils.ts

@@ -1,127 +0,0 @@
-import type { TableProps } from "./table.svelte";
-
-import { ctx } from "$lib/store.svelte";
-import {
-    Binary,
-    Braces,
-    Brackets,
-    Calendar,
-    CalendarClock,
-    Clock,
-    Hash,
-    Key,
-    Text,
-    Type,
-} from "lucide-svelte/icons";
-
-export function getCollectionColumns(collectionName: string): TableProps['columns'] {
-    const collectionFields = getFields(collectionName);
-    const headers: TableProps['columns'] = [];
-    for (const fieldName in collectionFields) {
-        const field = collectionFields[fieldName];
-        headers.push({
-            id: field.key,
-            subtext: field.type,
-            icon: getFieldIcon(fieldName, collectionName),
-        });
-    }
-    return headers;
-}
-
-export function getFieldIcon(fieldName: string, collectionName: string) {
-	const field = getField(fieldName, collectionName);
-	if (fieldName === "id") {
-		return Key;
-	} else if (field.type === "string") {
-		return Type;
-	} else if (field.type === "text") {
-		return Text;
-	} else if (field.type === "object") {
-		return Braces;
-	} else if (field.type === "array") {
-		return Brackets;
-	} else if (field.type === "bool") {
-		return Binary;
-	} else if (field.type === "integer") {
-		return Hash;
-	} else if (field.type === "long") {
-		return Hash;
-	} else if (field.type === "float") {
-		return Hash;
-	} else if (field.type === "decimal") {
-		return Hash;
-	} else if (field.type === "date") {
-		return Calendar;
-	} else if (field.type === "datetime") {
-		return CalendarClock;
-	} else if (field.type === "time") {
-		return Clock;
-	}
-
-	throw new Error(`(${field.type}) doesnt have an icon`);
-}
-
-export function getFields(collectionName: string) {
-	return ctx.meta.collections[collectionName].fields;
-}
-
-export function getField(fieldName: string, collectionName: string) {
-	return getFields(collectionName)[fieldName];
-}
-
-export function getCollectionPrimaryField(collectionName: string): string | undefined {
-	const collectionFields =
-			ctx.meta.collections[collectionName].fields;
-
-	const primaryFieldObject: any = Object.values(collectionFields).find(
-		(field) => (field as any).type === "string",
-	);
-
-	if (
-		primaryFieldObject &&
-		typeof primaryFieldObject === "object" &&
-		"key" in primaryFieldObject
-	) {
-		const fieldName = primaryFieldObject.key;
-		return fieldName;
-	}
-}
-
-export function getCollectionParamsFields(collectionName: string, allFields = false) {
-	const relations = ctx.meta.relations;
-	const foreignFields = relations
-		.filter((relation) => {
-			return relation.from.collection === collectionName
-		})
-		.map((relation) => {
-			return {
-				field: relation.from.field,
-				collection: relation.to.collection,
-			};
-		});
-
-	const columns = [];
-	for (let index = 0; index < foreignFields.length; index++) {
-		const foreignField = foreignFields[index];
-		if (!foreignField.collection) {
-			continue;
-		}
-		columns.push(`${foreignField.field}.id`);
-
-		if (!allFields) {
-			const primaryField = getCollectionPrimaryField(foreignField.collection)
-			if (primaryField) {
-				columns.push(`${foreignField.field}.${primaryField}`);
-			}
-		} else {
-			const fieldNames = Object.keys(ctx.meta.collections[foreignField.collection].fields);
-			for (let index = 0; index < fieldNames.length; index++) {
-				const fieldName = fieldNames[index];
-				columns.push(`${foreignField.field}.${fieldName}`);
-			}
-		}
-	}
-
-	const foreignColumns = columns.join(",");
-	return `*${foreignColumns ? `,${foreignColumns}` : ""}`;
-}

package/src/lib/components/detailView/store.svelte.ts

@@ -1,61 +0,0 @@
-import type { CreateDetailViewProp } from "./create/createDetailView.svelte";
-import type { UpdateDetailViewProp } from "./update/updateDetailView.svelte";
-import CreateDetailView from "./create/createDetailView.svelte";
-import UpdateDetailView from "./update/updateDetailView.svelte";
-import { lobb } from "$lib";
-import { getCollectionParamsFields } from "../dataTable/utils";
-import { mount, unmount } from "svelte";
-
-export function openCreateDetailView(props: CreateDetailViewProp) {
-    const targetElement = document.querySelector('main');
-
-    if (!targetElement) {
-        throw new Error("main html element doesn't exist for some reason")
-    }
-
-    const mountedCreateDetailView = mount(CreateDetailView, {
-        target: targetElement,
-        props: {
-            ...props,
-            onCancel: async () => {
-                props.onCancel?.()
-                await unmount(mountedCreateDetailView, {
-                    outro: true
-                });
-            }
-        },
-    })
-}
-
-export async function openUpdateDetailView(props: UpdateDetailViewProp) {
-    let params = {
-        fields: getCollectionParamsFields(props.collectionName, true),
-        filter: {
-            id: props.recordId,
-        },
-        limit: 1,
-    };
-    const response = await lobb.findAll(props.collectionName, params);
-    const result = await response.json();
-    const entry = result.data[0];
-
-    const targetElement = document.querySelector('main');
-
-    if (!targetElement) {
-        throw new Error("main html element doesn't exist for some reason")
-    }
-
-    const mountedUpdateDetailView = mount(UpdateDetailView, {
-        target: targetElement,
-        props: {
-            ...props,
-            onCancel: async () => {
-                props.onCancel?.()
-                await unmount(mountedUpdateDetailView, {
-                    outro: true
-                });
-            },
-            values: entry,
-        },
-    })
-}

package/src/lib/components/detailView/utils.ts

@@ -1,177 +0,0 @@
-import Mustache from "mustache";
-import { ctx } from "$lib/store.svelte";
-import { getFieldRelation } from "$lib/utils";
-import { getField } from "../dataTable/utils";
-import type { DetailFormField } from "./detailViewForm.svelte";
-
-export function getDefaultEntry(fieldNames: string[], collectionName: string, values?: Record<string, any>) {
-    return Object.fromEntries(
-        fieldNames.map((fieldName) => {
-            let value = null;
-            const field = getField(fieldName, collectionName);
-            if (values && values[fieldName] !== undefined) {
-                value = values[fieldName];
-            } else if (field.pre_processors?.default) {
-                const defualtValue = field.pre_processors.default;
-                if (typeof defualtValue === "string") {
-                    value = Mustache.render(defualtValue, {
-                        now: new Date().toISOString(),
-                    });
-                } else {
-                    value = defualtValue;
-                }
-            }
-            return [fieldName, value];
-        }),
-    );
-}
-
-export function serializeEntry(
-        collectionName: string,
-        entry: Record<string, any>,
-        rollback: boolean = false,
-) {
-    // deep clone the object
-    entry = { ...entry }
-
-    // serialize the foreign key field's value
-    for (const [fieldName, fieldValue] of Object.entries(entry)) {
-        const isRefrenceField = Boolean(getFieldRelation(collectionName, fieldName));
-        if (isRefrenceField && fieldValue !== null && fieldValue.id !== undefined) {
-            entry[fieldName] = fieldValue.id;
-        }
-    }
-
-    // check for related collections properties and serialize them too
-    if (!rollback) {
-        const childrenRelations = ctx.meta.relations.filter((relation) => relation.to.collection === collectionName);
-        const childrenCollectionNames = childrenRelations.map((relation) => relation.from.collection);
-        for (let index = 0; index < childrenCollectionNames.length; index++) {
-            const childrenCollectionName = childrenCollectionNames[index];
-            const childrenEntries = entry[childrenCollectionName];
-            if (childrenEntries) {
-                for (let index = 0; index < childrenEntries.length; index++) {
-                    childrenEntries[index] = serializeEntry(childrenCollectionName, childrenEntries[index]);
-                }
-            }
-        }
-    }
-
-    return entry;
-}
-
-export function generateTransactionBody(
-        collectionName: string,
-        entry: Record<string, any>,
-) {
-    entry = { ...entry }
-    function handleEntryRecursive(
-        transactionBody: any[],
-        collectionName: string,
-        entry: Record<string, any>,
-        parentTransactionIndex?: number,
-    ) {
-        const parentCollectionName = parentTransactionIndex !== undefined ? transactionBody[parentTransactionIndex].collection : null;
-        const foreignKeyFieldName = ctx.meta.relations.find(relation => relation.from.collection === collectionName && relation.to.collection === parentCollectionName)?.from.field;
-        const collectionFieldNames = Object.keys(ctx.meta.collections[collectionName].fields);
-        const payload: any = {};
-        for (let index = 0; index < collectionFieldNames.length; index++) {
-            const fieldName = collectionFieldNames[index];
-            const isForeignKeyField = fieldName === foreignKeyFieldName;
-            if (isForeignKeyField) {
-                payload[fieldName] = `{{ responses[${parentTransactionIndex}].data.id }}`
-                continue;
-            }
-
-            payload[fieldName] = entry[fieldName];
-        }
-
-        const localTransactionIndex = transactionBody.length;
-        if (payload.id) {
-            const localPayload = {
-                [foreignKeyFieldName]: payload[foreignKeyFieldName],
-            };
-            transactionBody.push({
-                collection: collectionName,
-                method: "updateMany",
-                args: [
-                    localPayload,
-                    {
-                        id: payload.id
-                    }
-                ],
-            });
-        } else {
-            transactionBody.push({
-                collection: collectionName,
-                method: "createOne",
-                args: [payload],
-            });
-        }
-
-        const childrenRelations = ctx.meta.relations.filter((relation) => relation.to.collection === collectionName);
-        const childrenCollectionNames = childrenRelations.map((relation) => relation.from.collection);
-        for (let index = 0; index < childrenCollectionNames.length; index++) {
-            const childrenCollectionName = childrenCollectionNames[index];
-            const childrenEntries = entry[childrenCollectionName];
-            if (childrenEntries) {
-                for (let index = 0; index < childrenEntries.length; index++) {
-                    const childrenEntry = childrenEntries[index];
-                    handleEntryRecursive(transactionBody, childrenCollectionName, childrenEntry, localTransactionIndex);
-                }
-            }
-        }
-    }
-
-    const transactionBody: any[] = [];
-
-    handleEntryRecursive(transactionBody, collectionName, entry);
-
-    return transactionBody
-}
-
-export function parseDetailViewValues(collectionName: string, values: Record<string, any>) {
-    const forignFieldNames = ctx.meta.relations
-        .filter((relation) => relation.from.collection === collectionName)
-        .map((relation) => relation.from.field);
-    const childCollectionNames = ctx.meta.relations
-        .filter((relation) => relation.to.collection === collectionName)
-        .map((relation) => relation.from.collection);
-
-    for (const [key, value] of Object.entries(values)) {
-        if (forignFieldNames.includes(key)) {
-            if (typeof value === 'number') {
-                values[key] = {
-                    id: value,
-                }
-            }
-        } else if (childCollectionNames.includes(key)) {
-            for (let index = 0; index < values[key].length; index++) {
-                parseDetailViewValues(key, values[key][index]);
-            }
-        }
-    }
-}
-
-export function getCollectionFields(collectionName: string) {
-    let returnedData: DetailFormField[] = [];
-
-    const collectionFields = ctx.meta.collections[collectionName].fields;
-    const isSingleton = ctx.meta.collections[collectionName].singleton;
-    for (const [fieldName, value] of Object.entries(collectionFields)) {
-
-        if (isSingleton && fieldName === "id") {
-            continue;
-        }
-
-        returnedData.push({
-            type: "input",
-            key: fieldName,
-            label: fieldName,
-            disabled: fieldName == "id",
-            placeholder: fieldName == "id" ? "AUTO_GENERATED" : "",
-        })
-    }
-
-    return returnedData;
-}

package/src/lib/components/loadingTypesForMonacoEditor.ts

@@ -1,36 +0,0 @@
-/**
- * TODO
- * 
- * this file shows an example of downloading the types files of a library from npm to use them in adding type support of that library in the vscode editor
- * so the whole point is that for users to be able to paste a url from npm or jsr of a library and have all ts support from its types
- */
-
-import { gunzipSync } from "fflate";
-import { untar } from "@andrewbranch/untar.js";
-
-async function extractTgz(buffer: ArrayBuffer) {
-    const tarBuffer = gunzipSync(new Uint8Array(buffer));
-
-    const cleanBuffer = tarBuffer.buffer.slice(
-        tarBuffer.byteOffset,
-        tarBuffer.byteOffset + tarBuffer.byteLength,
-    );
-    const files = await untar(cleanBuffer as ArrayBuffer);
-
-    const dtsFiles = [];
-
-    for (const file of files) {
-        if (file.filename.endsWith(".d.ts")) {
-            const content = new TextDecoder().decode(file.fileData);
-            dtsFiles.push({ name: file.filename, content });
-        }
-    }
-
-    return dtsFiles;
-}
-
-const tgzURL = "https://registry.npmjs.org/zod/-/zod-3.22.4.tgz";
-const response = await fetch(tgzURL);
-const arrayBuffer = await response.arrayBuffer();
-
-const files = await extractTgz(arrayBuffer);