@lobb-js/studio 0.1.31 → 0.1.32

package/{src/lib/components → dist}/LlmButton.svelte

@@ -1,11 +1,11 @@
 <script lang="ts">
-	import { lobb } from "$lib";
+	import { lobb } from "..";
 	import { Brain, LoaderIcon, Send } from "lucide-svelte";
 	import Button, { type ButtonProps } from "./ui/button/button.svelte";
 	import * as Popover from "./ui/popover";
 	import Textarea from "./ui/textarea/textarea.svelte";
 	import { toast } from "svelte-sonner";
-	import { ctx } from "$lib/store.svelte";
+	import { ctx } from "../store.svelte";
 
 	interface LocalProp {
 		value?: any;

package/dist/LlmButton.svelte.d.ts

@@ -0,0 +1,17 @@
+import { type ButtonProps } from "./ui/button/button.svelte";
+interface LocalProp {
+    value?: any;
+    title: string;
+    description?: string;
+    placeholder?: string;
+    format?: any;
+    messages?: any[];
+    variant?: ButtonProps["variant"];
+    class?: ButtonProps["class"];
+    Icon?: ButtonProps["Icon"];
+    children?: ButtonProps["children"];
+    onApiResponseComplete?: (res: any) => Promise<void>;
+}
+declare const LlmButton: import("svelte").Component<LocalProp, {}, "value">;
+type LlmButton = ReturnType<typeof LlmButton>;
+export default LlmButton;

package/{src → dist}/Studio.svelte

@@ -1,26 +1,26 @@
 <script lang="ts">
-    import { Toaster } from "./lib/components/ui/sonner";
+    import { Toaster } from "./ui/sonner";
     import { onMount, onDestroy } from "svelte";
     import { ModeWatcher } from "mode-watcher";
-    import { ctx } from "$lib/store.svelte";
-    import { lobb } from "$lib/index";
-    import Header from "$lib/components/header.svelte";
+    import { ctx } from "../store.svelte";
+    import { lobb } from "..";
+    import Header from "./header.svelte";
     import { LoaderCircle, ServerOff } from "lucide-svelte";
-    import Dialog from "$lib/components/confirmationDialog/confirmationDialog.svelte";
-    import MiniSidebar from "$lib/components/miniSidebar.svelte";
-    import SetServerPage from "$lib/components/setServerPage.svelte";
-    import * as Tooltip from "$lib/components/ui/tooltip";
+    import Dialog from "./confirmationDialog/confirmationDialog.svelte";
+    import MiniSidebar from "./miniSidebar.svelte";
+    import SetServerPage from "./setServerPage.svelte";
+    import * as Tooltip from "./ui/tooltip";
     import { Router, Route, Fallback, init as initRouter,  } from "@wjfe/n-savant";
     import {
         executeExtensionsOnStartup,
         loadExtensions,
-    } from "./extensions/extensionUtils";
-    import { mediaQueries } from "$lib/utils";
-    import Home from "./routes/home.svelte";
-    import DataModel from "./routes/data_model/dataModel.svelte";
-    import Collections from "./routes/collections/collections.svelte";
-    import Workflows from "./routes/workflows/workflows.svelte";
-    import Extension from "./routes/extensions/extension.svelte";
+    } from "../extensions/extensionUtils";
+    import { mediaQueries } from "../utils";
+    import Home from "../../routes/home.svelte";
+    import DataModel from "../../routes/data_model/dataModel.svelte";
+    import Collections from "../../routes/collections/collections.svelte";
+    import Workflows from "../../routes/workflows/workflows.svelte";
+    import Extension from "../../routes/extensions/extension.svelte";
 
     interface StudioProps {
       extensions?: any[];

package/dist/Studio.svelte.d.ts

@@ -0,0 +1,6 @@
+interface StudioProps {
+    extensions?: any[];
+}
+declare const Studio: import("svelte").Component<StudioProps, {}, "">;
+type Studio = ReturnType<typeof Studio>;
+export default Studio;

package/{src/lib/components → dist}/alertView.svelte

@@ -1,5 +1,5 @@
 <script lang="ts">
-  import * as Alert from "$lib/components/ui/alert/index.js";
+  import * as Alert from "./ui/alert/index.js";
   import { AlertCircleIcon } from "lucide-svelte";
   import type { Snippet } from "svelte";
 

package/dist/alertView.svelte.d.ts

@@ -0,0 +1,8 @@
+import type { Snippet } from "svelte";
+interface Props {
+    title: string;
+    children: Snippet<[]>;
+}
+declare const AlertView: import("svelte").Component<Props, {}, "">;
+type AlertView = ReturnType<typeof AlertView>;
+export default AlertView;

package/{src/lib/components → dist}/breadCrumbs.svelte

@@ -1,7 +1,7 @@
 <script lang="ts">
 	import * as Breadcrumb from "./ui/breadcrumb";
-	import { ctx } from "$lib/store.svelte";
-	import { mediaQueries } from "$lib/utils";
+	import { ctx } from "../store.svelte";
+	import { mediaQueries } from "../utils";
 	import { location } from "@wjfe/n-savant";
 
 	const isSmall = $derived(!mediaQueries.sm.current);

package/dist/breadCrumbs.svelte.d.ts

@@ -0,0 +1,3 @@
+declare const BreadCrumbs: import("svelte").Component<Record<string, never>, {}, "">;
+type BreadCrumbs = ReturnType<typeof BreadCrumbs>;
+export default BreadCrumbs;

package/{src/lib/components → dist}/combobox.svelte

@@ -2,10 +2,10 @@
     import CheckIcon from "@lucide/svelte/icons/check";
     import ChevronsUpDownIcon from "@lucide/svelte/icons/chevrons-up-down";
     import { tick } from "svelte";
-    import * as Command from "$lib/components/ui/command/index.js";
-    import * as Popover from "$lib/components/ui/popover/index.js";
-    import { Button } from "$lib/components/ui/button/index.js";
-    import { cn } from "$lib/utils.js";
+    import * as Command from "./ui/command/index.js";
+    import * as Popover from "./ui/popover/index.js";
+    import { Button } from "./ui/button/index.js";
+    import { cn } from "../utils.js";
     import type { HTMLButtonAttributes } from "svelte/elements";
 
     interface Option {

package/dist/combobox.svelte.d.ts

@@ -0,0 +1,15 @@
+import type { HTMLButtonAttributes } from "svelte/elements";
+interface Option {
+    value: string;
+    label: string;
+}
+interface Props {
+    placeholder: string;
+    searchPlaceholder: string;
+    options: Option[];
+    value: string;
+    buttonClass?: HTMLButtonAttributes["class"];
+}
+declare const Combobox: import("svelte").Component<Props, {}, "value">;
+type Combobox = ReturnType<typeof Combobox>;
+export default Combobox;

package/{src/lib/components → dist}/confirmationDialog/confirmationDialog.svelte

@@ -1,5 +1,5 @@
 <script lang="ts">
-	import * as AlertDialog from "$lib/components/ui/alert-dialog/index";
+	import * as AlertDialog from "../ui/alert-dialog/index";
 	import { Check, X } from "lucide-svelte";
 	import Button from "../ui/button/button.svelte";
 

package/dist/confirmationDialog/confirmationDialog.svelte.d.ts

@@ -0,0 +1,8 @@
+interface DialogProps {
+    title: string;
+    description: string;
+    onDecision: (result: boolean) => void;
+}
+declare const ConfirmationDialog: import("svelte").Component<DialogProps, {}, "">;
+type ConfirmationDialog = ReturnType<typeof ConfirmationDialog>;
+export default ConfirmationDialog;

package/dist/confirmationDialog/store.svelte.d.ts

@@ -0,0 +1 @@
+export declare function showDialog(title: string, description: string): Promise<boolean>;

package/dist/confirmationDialog/store.svelte.js

@@ -0,0 +1,69 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+import { mount, unmount } from "svelte";
+import ConfirmationDialog from "./confirmationDialog.svelte";
+export function showDialog(title, description) {
+    var _this = this;
+    return new Promise(function (resolve) {
+        var targetElement = document.querySelector('main');
+        if (!targetElement) {
+            throw new Error("main html element doesn't exist for some reason");
+        }
+        var mountedElement = mount(ConfirmationDialog, {
+            target: targetElement,
+            props: {
+                title: title,
+                description: description,
+                onDecision: function (result) { return __awaiter(_this, void 0, void 0, function () {
+                    return __generator(this, function (_a) {
+                        switch (_a.label) {
+                            case 0:
+                                resolve(result);
+                                return [4 /*yield*/, unmount(mountedElement, {
+                                        outro: true
+                                    })];
+                            case 1:
+                                _a.sent();
+                                return [2 /*return*/];
+                        }
+                    });
+                }); }
+            },
+        });
+        console.log("the dialog is mounted man");
+    });
+}

package/{src/lib/components → dist}/createManyButton.svelte

@@ -4,8 +4,8 @@
 	import Button, { type ButtonProps } from "./ui/button/button.svelte";
 	import { toast } from "svelte-sonner";
 	import MonacoEditor from "./monacoEditor.svelte";
-	import { lobb } from "$lib";
-	import { calculateDrawerWidth } from "$lib/utils";
+	import { lobb } from "..";
+	import { calculateDrawerWidth } from "../utils";
   import Drawer from "./drawer.svelte";
 
 	interface LocalProps extends ButtonProps {

package/dist/createManyButton.svelte.d.ts

@@ -0,0 +1,8 @@
+import { type ButtonProps } from "./ui/button/button.svelte";
+interface LocalProps extends ButtonProps {
+    collectionName: string;
+    onSuccessfullSave?: () => Promise<void>;
+}
+declare const CreateManyButton: import("svelte").Component<LocalProps, {}, "">;
+type CreateManyButton = ReturnType<typeof CreateManyButton>;
+export default CreateManyButton;

package/{src/lib/components → dist}/dataTable/childRecords.svelte

@@ -1,10 +1,10 @@
 <script lang="ts">
-    import { ctx } from "$lib/store.svelte";
+    import { ctx } from "../../store.svelte";
     import { ChevronRight, Plus, Smartphone, Table } from "lucide-svelte";
     import DataTable from "./dataTable.svelte";
     import CreateDetailViewButton from "../detailView/create/createDetailViewButton.svelte";
     import ExtensionsComponents from "../extensionsComponents.svelte";
-    import { getExtensionUtils } from "../../../extensions/extensionUtils";
+    import { getExtensionUtils } from "../../extensions/extensionUtils";
 
     interface Props {
         collectionName: string;

package/dist/dataTable/childRecords.svelte.d.ts

@@ -0,0 +1,9 @@
+interface Props {
+    collectionName: string;
+    recordId: string;
+    width: number;
+    unifiedBgColor?: "bg-soft" | "bg-background";
+}
+declare const ChildRecords: import("svelte").Component<Props, {}, "">;
+type ChildRecords = ReturnType<typeof ChildRecords>;
+export default ChildRecords;

package/{src/lib/components → dist}/dataTable/dataTable.svelte

@@ -1,6 +1,6 @@
 <script lang="ts">
     import _ from "lodash";
-    import { lobb } from "$lib";
+    import { lobb } from "../..";
     import Footer from "./footer.svelte";
     import Header from "./header.svelte";
     import Table, { type TableProps } from "./table.svelte";
@@ -10,11 +10,11 @@
     import ChildRecords from "./childRecords.svelte";
     import FieldCell from "./fieldCell.svelte";
     import Skeleton from "../ui/skeleton/skeleton.svelte";
-    import { ctx } from "$lib/store.svelte";
+    import { ctx } from "../../store.svelte";
     import Button from "../ui/button/button.svelte";
     import { showDialog } from "../confirmationDialog/store.svelte";
     import UpdateDetailViewButton from "../detailView/update/updateDetailViewButton.svelte";
-    import { emitEvent } from "$lib/eventSystem";
+    import { emitEvent } from "../../eventSystem";
     import type { Snippet } from "svelte";
 
     interface Props {

package/dist/dataTable/dataTable.svelte.d.ts

@@ -0,0 +1,15 @@
+import { type TableProps } from "./table.svelte";
+import type { Snippet } from "svelte";
+interface Props {
+    collectionName: string;
+    filter?: any;
+    showHeader?: boolean;
+    showFooter?: boolean;
+    unifiedBgColor?: "bg-soft" | "bg-background";
+    showDelete?: boolean;
+    tableProps?: Partial<TableProps>;
+    headerLeft?: Snippet<[]>;
+}
+declare const DataTable: import("svelte").Component<Props, {}, "">;
+type DataTable = ReturnType<typeof DataTable>;
+export default DataTable;

package/{src/lib/components → dist}/dataTable/fieldCell.svelte

@@ -1,5 +1,5 @@
 <script lang="ts">
-    import { getFieldRelation } from "$lib/utils";
+    import { getFieldRelation } from "../../utils";
     import { ExternalLink } from "lucide-svelte";
     import UpdateDetailViewButton from "../detailView/update/updateDetailViewButton.svelte";
     import { getField } from "./utils";

package/dist/dataTable/fieldCell.svelte.d.ts

@@ -0,0 +1,10 @@
+interface Props {
+    collectionName: string;
+    fieldName: string;
+    value: any;
+    entry: Record<string, any>;
+    tableParams?: any;
+}
+declare const FieldCell: import("svelte").Component<Props, {}, "tableParams">;
+type FieldCell = ReturnType<typeof FieldCell>;
+export default FieldCell;

package/{src/lib/components → dist}/dataTable/filter.svelte

@@ -1,5 +1,5 @@
 <script lang="ts">
-    import * as Popover from "$lib/components/ui/popover/index.js";
+    import * as Popover from "../ui/popover/index.js";
     import Filter from "./filter.svelte";
     import {
         Plus,
@@ -11,7 +11,7 @@
     } from "lucide-svelte";
     import { buttonVariants } from "../ui/button";
     import _ from "lodash";
-    import { ctx } from "$lib/store.svelte";
+    import { ctx } from "../../store.svelte";
     import Button from "../ui/button/button.svelte";
 
     interface Props {

package/dist/dataTable/filter.svelte.d.ts

@@ -0,0 +1,10 @@
+import Filter from "./filter.svelte";
+interface Props {
+    filter: any;
+    collectionName: string;
+    isFirst?: boolean;
+    deleteFilter?: () => void;
+}
+declare const Filter: import("svelte").Component<Props, {}, "filter">;
+type Filter = ReturnType<typeof Filter>;
+export default Filter;

package/{src/lib/components → dist}/dataTable/filterButton.svelte

@@ -1,5 +1,5 @@
 <script lang="ts">
-	import * as Popover from "$lib/components/ui/popover/index.js";
+	import * as Popover from "../ui/popover/index.js";
 	import { ListFilter } from "lucide-svelte";
 	import { buttonVariants } from "../ui/button";
 	import Filter from "./filter.svelte";

package/dist/dataTable/filterButton.svelte.d.ts

@@ -0,0 +1,8 @@
+interface Props {
+    filter: any;
+    collectionName: string;
+    showText?: boolean;
+}
+declare const FilterButton: import("svelte").Component<Props, {}, "filter">;
+type FilterButton = ReturnType<typeof FilterButton>;
+export default FilterButton;

package/dist/dataTable/footer.svelte.d.ts

@@ -0,0 +1,8 @@
+interface Props {
+    limit: string;
+    totalCount: number;
+    currentPage: number;
+}
+declare const Footer: import("svelte").Component<Props, {}, "currentPage" | "limit">;
+type Footer = ReturnType<typeof Footer>;
+export default Footer;

package/{src/lib/components → dist}/dataTable/header.svelte

@@ -1,5 +1,5 @@
 <script lang="ts">
-    import { ctx } from "$lib/store.svelte";
+    import { ctx } from "../../store.svelte";
     import { ListRestart, Plus, SquareStack, Trash } from "lucide-svelte";
     import LlmButton from "../LlmButton.svelte";
     import FilterButton from "./filterButton.svelte";
@@ -7,7 +7,7 @@
     import Button from "../ui/button/button.svelte";
     import CreateManyButton from "../createManyButton.svelte";
     import { showDialog } from "../confirmationDialog/store.svelte";
-    import { lobb } from "$lib";
+    import { lobb } from "../..";
     import CreateDetailViewButton from "../detailView/create/createDetailViewButton.svelte";
     import type { Snippet } from "svelte";
 

package/dist/dataTable/header.svelte.d.ts

@@ -0,0 +1,10 @@
+import type { Snippet } from "svelte";
+interface Props {
+    collectionName: string;
+    params: any;
+    selectedRecords: string[];
+    left?: Snippet<[]>;
+}
+declare const Header: import("svelte").Component<Props, {}, "params" | "selectedRecords">;
+type Header = ReturnType<typeof Header>;
+export default Header;

package/{src/lib/components → dist}/dataTable/sort.svelte

@@ -1,12 +1,12 @@
 <script lang="ts">
     import _ from "lodash";
 
-    import * as Popover from "$lib/components/ui/popover/index.js";
+    import * as Popover from "../ui/popover/index.js";
     import { ArrowDown, ArrowUp, GripVertical, Plus, X } from "lucide-svelte";
     import Button, { buttonVariants } from "../ui/button/button.svelte";
     import Label from "../ui/label/label.svelte";
     import Switch from "../ui/switch/switch.svelte";
-    import { ctx } from "$lib/store.svelte";
+    import { ctx } from "../../store.svelte";
     import { getFieldIcon } from "./utils";
 
     interface Props {

package/dist/dataTable/sort.svelte.d.ts

@@ -0,0 +1,8 @@
+interface Props {
+    collectionName: string;
+    sort: Record<string, "asc" | "desc">;
+    showText: boolean;
+}
+declare const Sort: import("svelte").Component<Props, {}, "sort">;
+type Sort = ReturnType<typeof Sort>;
+export default Sort;

package/{src/lib/components → dist}/dataTable/sortButton.svelte

@@ -1,7 +1,7 @@
 <script lang="ts">
-	import * as Popover from "$lib/components/ui/popover/index.js";
+	import * as Popover from "../ui/popover/index.js";
 	import { ArrowDownWideNarrow } from "lucide-svelte";
-	import { buttonVariants } from "$lib/components/ui/button";
+	import { buttonVariants } from "../ui/button";
 	import Sort from "./sort.svelte";
 
 	interface Props {

package/dist/dataTable/sortButton.svelte.d.ts

@@ -0,0 +1,8 @@
+interface Props {
+    collectionName: string;
+    sort: Record<string, "asc" | "desc">;
+    showText: boolean;
+}
+declare const SortButton: import("svelte").Component<Props, {}, "sort">;
+type SortButton = ReturnType<typeof SortButton>;
+export default SortButton;

package/dist/dataTable/table.svelte.d.ts

@@ -0,0 +1,32 @@
+interface Column {
+    id: string;
+    icon?: any;
+    subtext?: any;
+}
+type Entry = Record<string, any>;
+interface Select {
+    onSelect: (entry: any) => void;
+}
+export interface TableProps {
+    data: Entry[];
+    columns?: Column[];
+    showCollapsible?: boolean;
+    sort?: Record<string, "asc" | "desc">;
+    localSorting?: boolean;
+    selectedRecords?: Array<any>;
+    selectByColumn?: string | null;
+    showCheckboxes?: boolean;
+    showLastRowBorder?: boolean;
+    showLastColumnBorder?: boolean;
+    overrideCell?: Snippet<[any, Column, Entry]>;
+    tools?: Snippet<[Entry, number]>;
+    collapsible?: Snippet<[Entry, number]>;
+    parentWidth?: number;
+    unifiedBgColor?: "bg-soft" | "bg-background";
+    select?: Select;
+    tableWidth?: number;
+}
+import type { Snippet } from "svelte";
+declare const Table: import("svelte").Component<TableProps, {}, "sort" | "selectedRecords" | "tableWidth">;
+type Table = ReturnType<typeof Table>;
+export default Table;

package/dist/dataTable/utils.d.ts

@@ -0,0 +1,7 @@
+import type { TableProps } from "./table.svelte";
+export declare function getCollectionColumns(collectionName: string): TableProps['columns'];
+export declare function getFieldIcon(fieldName: string, collectionName: string): any;
+export declare function getFields(collectionName: string): Record<string, any>;
+export declare function getField(fieldName: string, collectionName: string): any;
+export declare function getCollectionPrimaryField(collectionName: string): string | undefined;
+export declare function getCollectionParamsFields(collectionName: string, allFields?: boolean): string;

package/dist/dataTable/utils.js

@@ -0,0 +1,111 @@
+import { ctx } from "../../store.svelte";
+import { Binary, Braces, Brackets, Calendar, CalendarClock, Clock, Hash, Key, Text, Type, } from "lucide-svelte/icons";
+export function getCollectionColumns(collectionName) {
+    var collectionFields = getFields(collectionName);
+    var headers = [];
+    for (var fieldName in collectionFields) {
+        var field = collectionFields[fieldName];
+        headers.push({
+            id: field.key,
+            subtext: field.type,
+            icon: getFieldIcon(fieldName, collectionName),
+        });
+    }
+    return headers;
+}
+export function getFieldIcon(fieldName, collectionName) {
+    var 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("(".concat(field.type, ") doesnt have an icon"));
+}
+export function getFields(collectionName) {
+    return ctx.meta.collections[collectionName].fields;
+}
+export function getField(fieldName, collectionName) {
+    return getFields(collectionName)[fieldName];
+}
+export function getCollectionPrimaryField(collectionName) {
+    var collectionFields = ctx.meta.collections[collectionName].fields;
+    var primaryFieldObject = Object.values(collectionFields).find(function (field) { return field.type === "string"; });
+    if (primaryFieldObject &&
+        typeof primaryFieldObject === "object" &&
+        "key" in primaryFieldObject) {
+        var fieldName = primaryFieldObject.key;
+        return fieldName;
+    }
+}
+export function getCollectionParamsFields(collectionName, allFields) {
+    if (allFields === void 0) { allFields = false; }
+    var relations = ctx.meta.relations;
+    var foreignFields = relations
+        .filter(function (relation) {
+        return relation.from.collection === collectionName;
+    })
+        .map(function (relation) {
+        return {
+            field: relation.from.field,
+            collection: relation.to.collection,
+        };
+    });
+    var columns = [];
+    for (var index = 0; index < foreignFields.length; index++) {
+        var foreignField = foreignFields[index];
+        if (!foreignField.collection) {
+            continue;
+        }
+        columns.push("".concat(foreignField.field, ".id"));
+        if (!allFields) {
+            var primaryField = getCollectionPrimaryField(foreignField.collection);
+            if (primaryField) {
+                columns.push("".concat(foreignField.field, ".").concat(primaryField));
+            }
+        }
+        else {
+            var fieldNames = Object.keys(ctx.meta.collections[foreignField.collection].fields);
+            for (var index_1 = 0; index_1 < fieldNames.length; index_1++) {
+                var fieldName = fieldNames[index_1];
+                columns.push("".concat(foreignField.field, ".").concat(fieldName));
+            }
+        }
+    }
+    var foreignColumns = columns.join(",");
+    return "*".concat(foreignColumns ? ",".concat(foreignColumns) : "");
+}