@hostlink/nuxt-light 0.0.3

package/dist/runtime/components/l-table.vue

@@ -0,0 +1,333 @@
+<script setup>
+import { useQuasar } from 'quasar';
+const route = useRoute();
+const module = route.path.split("/")[1];
+const errors = ref([]);
+
+
+
+const props = defineProps({
+    columns: {
+        type: Array,
+        required: true
+    },
+    showActions: {
+        type: [Boolean, Array],
+        default: false
+    },
+    selection: {
+        type: String,
+        default: "none"
+    },
+    sortBy: {
+        type: String,
+        default: null
+    },
+})
+
+//apply all aligns to the columns 
+props.columns.forEach((col) => {
+    if (!col.align) {
+        col.align = "left";
+    }
+    if (!col.field && col.name) {
+        col.field = col.name
+    }
+
+    col.label = t(col.label)
+})
+
+const renderColumns = computed(() => {
+    let cols = [];
+    if (props.showActions) {
+        cols = [
+            {
+                name: "_actions",
+                align: "left"
+            },
+            ...props.columns
+        ]
+    } else {
+        cols = props.columns;
+    }
+    return cols;
+})
+
+const emits = defineEmits(["request"])
+
+const loading = ref(false);
+
+let activeEdit = false;
+let actionView = false;
+let actionDelete = false;
+if (props.showActions && props.showActions instanceof Array) {
+    actionView = props.showActions.includes("view");
+    activeEdit = props.showActions.includes("edit");
+    actionDelete = props.showActions.includes("delete");
+}
+
+
+const pagination = ref({
+    sortBy: null,
+    descending: true,
+    page: 1,
+    rowsPerPage: 10,
+    rowsNumber: 0
+})
+
+if (props.sortBy) {
+    let [sortBy, descending] = props.sortBy.split(":");
+    pagination.value.sortBy = sortBy;
+    pagination.value.descending = descending == "desc";
+}
+
+const hasSearch = computed(() => {
+    return props.columns.some((col) => {
+        return col.searchable;
+    })
+})
+
+const table = ref(null);
+
+const filters = ref({});
+const rows = ref([]);
+
+onMounted(() => {
+    table.value.requestServerInteraction();
+})
+
+let primaryKey = ref("");
+const recordName = ref("");
+const onRequest = async (p) => {
+
+    p.fields = [];
+    props.columns.forEach((col) => {
+        if (col.name.startsWith("_")) {
+            return;
+        }
+        if (p.fields.includes(col.name)) {
+            return;
+        }
+        p.fields.push(col.name);
+    });
+
+
+    if (actionDelete) {
+        p.fields.push("canDelete");
+    }
+
+    p.filters = getFilterValue();
+
+    loading.value = true;
+    p.done = (data) => {
+        loading.value = false;
+        rows.value = data.rows;
+        pagination.value.rowsPerPage = p.pagination.rowsPerPage;
+        pagination.value.page = p.pagination.page;
+        pagination.value.sortBy = p.pagination.sortBy;
+        pagination.value.descending = p.pagination.descending;
+
+        pagination.value = Object.assign(pagination.value, data.pagination);
+
+        pagination.value.rowsNumber = data.total;
+
+
+        primaryKey.value = data.key;
+        recordName.value = data.name;
+
+
+        if (props.showActions) {
+            if (props.showActions.includes("edit")) {
+                if (rows.value.length > 0) {
+                    //get first row
+                    let row = rows.value[0];
+                    //check has primary key
+
+                    if (!row[primaryKey.value]) {
+                        errors.value.push("[edit] Primary key not found in the data");
+                    }
+                }
+            }
+
+            if (props.showActions.includes("delete")) {
+                if (rows.value.length > 0) {
+                    //get first row
+                    let row = rows.value[0];
+                    //check has primary key
+
+                    if (!row[primaryKey.value]) {
+                        errors.value.push("[delete] Primary key not found in the data");
+                    }
+                }
+            }
+
+        }
+
+
+    }
+
+    if (p.pagination.sortBy) {
+        p.sort = p.pagination.sortBy + ":" + (p.pagination.descending ? "desc" : "asc")
+    }
+
+    p.limit = p.pagination.rowsPerPage;
+    p.offset = (p.pagination.page - 1) * p.pagination.rowsPerPage;
+
+
+
+    emits("request", p);
+
+}
+
+const getFilterValue = () => {
+    let f = {};
+
+    props.columns.forEach((col) => {
+        if (col.searchable) {
+            if (filters.value[col.name]) {
+
+                if (col.searchType == "date") {
+                    if (filters.value[col.name].from) {
+                        f[col.name] = {
+                            between: [filters.value[col.name].from, filters.value[col.name].to]
+                        }
+                    }
+                } else {
+                    f[col.name] = {
+                        contains: filters.value[col.name]
+                    }
+                }
+
+            }
+        }
+    });/* 
+    Object.entries(filters.value).forEach(([key, value]) => {
+
+
+        f[key] = {
+            contains: value
+        }
+    }) */
+
+
+    return f;
+}
+
+
+const onFilters = () => {
+    //clone the filters
+
+
+    onRequest({
+        pagination: {
+            page: 1,
+            rowsPerPage: pagination.value.rowsPerPage,
+            sortBy: pagination.value.sortBy,
+            descending: pagination.value.descending
+        }
+    })
+}
+
+const slots = useSlots();
+
+const ss = Object.entries(slots).map(([key, value]) => {
+    return key;
+});
+
+
+/*
+let MyComp = h("div", null, ["abc"])
+
+console.log(MyComp)
+ */
+
+
+
+
+
+const qua = useQuasar();
+const onDelete = async (id) => {
+
+    try {
+        await removeObject(recordName.value, id)
+    } catch (e) {
+
+        qua.notify({
+            message: e.message,
+            color: "negative",
+            icon: "report_problem"
+        })
+
+
+        return;
+
+    }
+
+
+    // refresh the table
+    table.value.requestServerInteraction();
+
+}
+
+
+</script>
+<template>
+    <template v-if="errors.length > 0">
+        <div class="text-white bg-negative">
+            <ul>
+                <li v-for="e in errors">{{ e }}</li>
+            </ul>
+        </div>
+    </template>
+
+    <q-table flat bordered :columns="renderColumns" v-model:pagination="pagination" ref="table" :loading="loading"
+        @request="onRequest" :selection="selection" :rows="rows">
+
+        <template v-for="s in ss" v-slot:[s]="props">
+            <slot :name="s" v-bind="props"></slot>
+        </template>
+
+
+        <template #body-cell-_actions="props">
+            <q-td :props="props" auto-width>
+                <div class="text-grey-8">
+
+                    <l-view-btn :to="`/${recordName}/${props.row[primaryKey]}/view`" v-if="actionView"></l-view-btn>
+
+                    <l-edit-btn :to="`/${recordName}/${props.row[primaryKey]}/edit`" v-if="activeEdit"></l-edit-btn>
+
+                    <l-delete-btn v-if="actionDelete && props.row.canDelete"
+                        @submit="onDelete(props.row[primaryKey])"></l-delete-btn>
+
+                    <slot name="actions" v-bind="props"></slot>
+                </div>
+            </q-td>
+        </template>
+
+
+
+        <template #top-row="props" v-if="hasSearch">
+            <q-tr>
+                <q-td v-if="selection != 'none'" auto-width>
+
+                </q-td>
+                <q-td v-for="col in props.cols">
+                    <template v-if="col.searchable">
+                        <template v-if="col.searchType == 'date'">
+                            <l-date-picker hide-bottom-space v-model="filters[col.name]" dense
+                                @update:model-value="onFilters" clearable range @clear="onFilters" />
+                        </template>
+
+                        <template v-else>
+                            <q-input dense clearable v-model="filters[col.name]" @keydown.enter.prevent="onFilters"
+                                @clear="onFilters"></q-input>
+
+                        </template>
+
+                    </template>
+                </q-td>
+            </q-tr>
+        </template>
+
+    </q-table>
+</template>

package/dist/runtime/components/l-tabs.vue

@@ -0,0 +1,5 @@
+<template>
+    <q-tabs class="text-grey" active-color="primary" indicator-color="primary" align="justify">
+        <slot></slot>
+    </q-tabs>
+</template>

package/dist/runtime/components/l-time-picker.vue

@@ -0,0 +1,28 @@
+<script setup>
+const props = defineProps(["modelValue"]);
+const emit = defineEmits(["update:modelValue"]);
+const popup = ref(null);
+const localValue = computed({
+    get: () => props.modelValue,
+    set: (value) => {
+      //  popup.value.hide();
+        emit('update:modelValue', value)
+    }
+
+});
+</script>
+<template>
+    <q-input v-model="localValue" mask="time" :rules="['time']">
+        <template v-slot:prepend>
+            <q-icon name="access_time" class="cursor-pointer">
+                <q-popup-proxy cover transition-show="scale" transition-hide="scale" ref="popup">
+                    <q-time v-model="localValue" format24h>
+                        <div class="row items-center justify-end">
+                            <q-btn v-close-popup label="Close" color="primary" flat />
+                        </div>
+                    </q-time>
+                </q-popup-proxy>
+            </q-icon>
+        </template>
+    </q-input>
+</template>

package/dist/runtime/components/l-view-btn.vue

@@ -0,0 +1,3 @@
+<template>
+    <q-btn flat round dense icon="sym_o_search" />
+</template>

package/dist/runtime/composables/addObject.d.ts

@@ -0,0 +1,2 @@
+declare const _default: (name: string, data: Object) => Promise<any>;
+export default _default;

package/dist/runtime/composables/addObject.mjs

@@ -0,0 +1,6 @@
+export default async (name, data) => {
+  let resp = await m(`add${name}`, {
+    data
+  });
+  return resp.data[`add${name}`];
+};

package/dist/runtime/composables/f.d.ts

@@ -0,0 +1 @@
+export default function (operation: string, args: any, fields?: any): string;

package/dist/runtime/composables/f.mjs

@@ -0,0 +1,27 @@
+import { jsonToGraphQLQuery } from "json-to-graphql-query";
+export default function(operation, args, fields = []) {
+  if (arguments.length === 2) {
+    fields = args;
+    args = {};
+  }
+  let query = {};
+  query[operation] = {};
+  if (args) {
+    query[operation] = {
+      __args: args
+    };
+  }
+  fields.forEach(async (field) => {
+    if (typeof field === "string") {
+      query[operation][field] = true;
+    } else if (typeof field === "object") {
+      Object.entries(field).forEach(([key, value]) => {
+        query[operation][key] = {};
+        value.forEach((subField) => {
+          query[operation][key][subField] = true;
+        });
+      });
+    }
+  });
+  return jsonToGraphQLQuery(query);
+}

package/dist/runtime/composables/getApiUrl.d.ts

@@ -0,0 +1 @@
+export default function getApiUrl(url: String, params: any): string;

package/dist/runtime/composables/getApiUrl.mjs

@@ -0,0 +1,4 @@
+export default function getApiUrl(url, params) {
+  const urlParams = new URLSearchParams(params).toString();
+  return `/api/${url}?${urlParams}`;
+}

package/dist/runtime/composables/getCurrentUser.d.ts

@@ -0,0 +1,2 @@
+declare const _default: () => Promise<any>;
+export default _default;

package/dist/runtime/composables/getCurrentUser.mjs

@@ -0,0 +1,8 @@
+export default async () => {
+  try {
+    return await q("my", ["first_name", "last_name", "roles"]);
+  } catch (e) {
+    return null;
+  }
+  return null;
+};

package/dist/runtime/composables/getObject.d.ts

@@ -0,0 +1 @@
+export default function (fields?: Array<string>): Promise<any>;

package/dist/runtime/composables/getObject.mjs

@@ -0,0 +1,20 @@
+export default async function(fields = []) {
+  let route = useRoute();
+  if (!route.name) {
+    return;
+  }
+  const [module, id_name] = route.name.split("-");
+  const id = parseInt(route.params[id_name]);
+  const filters = {};
+  filters[id_name] = id;
+  if (fields.length == 0) {
+    fields.push(id_name);
+  }
+  let { data } = await listData(module, {
+    filters
+  }, fields);
+  if (data.length > 0) {
+    return data[0];
+  }
+  return null;
+}

package/dist/runtime/composables/id.d.ts

@@ -0,0 +1,2 @@
+declare const _default: () => Number;
+export default _default;

package/dist/runtime/composables/id.mjs

@@ -0,0 +1,12 @@
+const route = useRoute();
+export default () => {
+  let route2 = useRoute();
+  let name = route2.name?.toString();
+  if (name == void 0)
+    return 0;
+  let parts = name.split("-");
+  const module = parts[0];
+  const moduleLower = module.charAt(0).toLowerCase() + module.slice(1);
+  const keyname = parts[1];
+  return parseInt(route2.params[keyname]);
+};

package/dist/runtime/composables/list.d.ts

@@ -0,0 +1 @@
+export default function listData(name: string, props?: any, fields?: Array<string>): Promise<any>;

package/dist/runtime/composables/list.mjs

@@ -0,0 +1,33 @@
+export default async function listData(name, props = {}, fields = []) {
+  let v = {};
+  if (props.sort) {
+    v.sort = props.sort;
+  }
+  if (props.filters) {
+    v.filters = {
+      value: props.filters,
+      type: "mixed"
+    };
+  }
+  let offset_limit = {};
+  if (props.offset) {
+    offset_limit.offset = props.offset;
+  }
+  if (props.limit) {
+    offset_limit.limit = props.limit;
+  }
+  const fs = fields;
+  if (props.fields) {
+    fs.push(...props.fields);
+  }
+  let data = await q(`list${name}`, v, [f("data", offset_limit, fs), f("meta", ["total", "key", "name"])]);
+  if (props.done) {
+    props.done({
+      rows: data[`list${name}`].data,
+      total: data[`list${name}`].meta.total,
+      key: data[`list${name}`].meta.key,
+      name: data[`list${name}`].meta.name
+    });
+  }
+  return data[`list${name}`][`data`];
+}

package/dist/runtime/composables/listData.d.ts

@@ -0,0 +1 @@
+export default function listData(name: string, props?: any, fields?: Array<string>): Promise<any>;

package/dist/runtime/composables/listData.mjs

@@ -0,0 +1,30 @@
+export default async function listData(name, props = {}, fields = []) {
+  let v = {};
+  if (props.sort) {
+    v.sort = props.sort;
+  }
+  if (props.filters) {
+    v.filters = props.filters;
+  }
+  let offset_limit = {};
+  if (props.offset) {
+    offset_limit.offset = props.offset;
+  }
+  if (props.limit) {
+    offset_limit.limit = props.limit;
+  }
+  const fs = fields;
+  if (props.fields) {
+    fs.push(...props.fields);
+  }
+  let data = await q(`list${name}`, v, [f("data", offset_limit, fs), f("meta", ["total", "key", "name"])]);
+  if (props.done) {
+    props.done({
+      rows: data.data,
+      total: data.meta.total,
+      key: data.meta.key,
+      name: data.meta.name
+    });
+  }
+  return data;
+}

package/dist/runtime/composables/login.d.ts

@@ -0,0 +1,2 @@
+declare const _default: (username: string, password: string) => Promise<boolean>;
+export default _default;

package/dist/runtime/composables/login.mjs

@@ -0,0 +1,17 @@
+import mutation from "./mutation.mjs";
+export default async (username, password) => {
+  await mutation({
+    operation: "login",
+    variables: {
+      username: {
+        value: username,
+        required: true
+      },
+      password: {
+        value: password,
+        required: true
+      }
+    }
+  });
+  return true;
+};

package/dist/runtime/composables/m.d.ts

@@ -0,0 +1 @@
+export default function _default(operation: any, args: any, fields?: any[]): Promise<any>;

package/dist/runtime/composables/m.mjs

@@ -0,0 +1,73 @@
+import axios from 'axios';
+//import { mutation } from 'gql-query-builder';
+import { jsonToGraphQLQuery } from 'json-to-graphql-query';
+
+export default async function (operation, args, fields = []) {
+
+    const mutation = {
+        mutation: {
+
+        }
+    }
+
+
+    mutation.mutation[operation] = {};
+    if (args) {
+        mutation.mutation[operation].__args = args;
+
+    }
+
+
+    let map = {};
+    let map_values = [];
+
+    fields.forEach(field => {
+
+        if (typeof field === 'string') {
+            mutation.mutation[operation][field] = true;
+        } else {
+            mutation.mutation.__variables = mutation.mutation.__variables || {};
+
+            let i = 0;
+            Object.entries(field.__variables).forEach(([key, value]) => {
+                mutation.mutation.__variables[key] = value.type;
+                map[i] = ["variables." + key];
+                map_values.push(value.value);
+                i++;
+            });
+        }
+    });
+
+
+    const graphql_query = jsonToGraphQLQuery(mutation);
+    let service = axios.create({
+        withCredentials: true
+    });
+
+    let data = null;
+    if (map_values.length) {
+        const fd = new FormData;
+
+        fd.append("operations", JSON.stringify({
+            query: graphql_query
+        }));
+        fd.append("map", JSON.stringify(map));
+        for (let i = 0; i < map_values.length; i++) {
+            fd.append(i, map_values[i]);
+        }
+        data = (await service.post("/api/", fd)).data;
+
+    } else {
+        data = (await service.post("/api/", {
+            query: graphql_query
+        })).data;
+    }
+
+    if (data.errors) {
+        throw new Error(data.errors[0].message);
+    }
+
+    return data.data[operation];
+
+
+}

package/dist/runtime/composables/mutation.d.ts

@@ -0,0 +1 @@
+export default function _default(options: any): Promise<any>;

package/dist/runtime/composables/mutation.mjs

@@ -0,0 +1,23 @@
+import axios from 'axios';
+import { mutation } from 'gql-query-builder';
+
+export default async function (options) {
+
+
+    let service = axios.create({
+        withCredentials: true
+    });
+
+    
+
+    const data = (await service.post("/api/", mutation(options))).data;
+
+
+    if (data.errors) {
+        throw new Error(data.errors[0].message);
+    }
+
+    return data;
+
+
+}

package/dist/runtime/composables/q.d.ts

@@ -0,0 +1 @@
+export default function (operation: string, args: any, fields?: Array<any>): Promise<any>;