@paris-ias/list 1.0.3 → 1.0.5

package/src/runtime/graphql/queries/list/search.gql

@@ -0,0 +1,148 @@
+query search($appId: ID = "", $search: String = "", $lang: String = "en") {
+  search(appId: $appId, search: $search, lang: $lang) {
+    people {
+      items {
+        firstname
+        id
+        image {
+          alt
+          backgroundColor
+          caption
+          copyright
+          license
+          licenseUrl
+          url
+        }
+        lastname
+        slug
+      }
+      total
+    }
+    projects {
+      items {
+        date
+        id
+        featured
+        name
+        image {
+          alt
+          backgroundColor
+          caption
+          copyright
+          license
+          licenseUrl
+          url
+        }
+        subtitle
+        tags {
+          name
+        }
+        slug {
+          fr
+          en
+        }
+      }
+      total
+    }
+    publications {
+      items {
+        subtitle
+        name
+        image {
+          alt
+          backgroundColor
+          caption
+          copyright
+          licenseUrl
+          license
+          url
+        }
+        id
+        date
+        slug {
+          fr
+          en
+        }
+      }
+      total
+    }
+    events {
+      items {
+        availableSlots
+        bookingState
+        category
+        start
+        state
+        summary
+        eventType
+        slug {
+          fr
+          en
+        }
+        name
+        image {
+          alt
+          backgroundColor
+          caption
+          copyright
+          licenseUrl
+          license
+          url
+        }
+      }
+      total
+    }
+    fellowships {
+      total
+      items {
+        applicationStart
+        applicationStop
+        disciplines {
+          name
+        }
+        fellowshipStart
+        fellowshipType
+        fellowshipStop
+        id
+        image {
+          alt
+          backgroundColor
+          caption
+          copyright
+          license
+          licenseUrl
+          url
+        }
+        name
+        summary
+        slug {
+          fr
+          en
+        }
+      }
+    }
+    news {
+      total
+      items {
+        category
+        date
+        featured
+        id
+        image {
+          alt
+          backgroundColor
+          caption
+          copyright
+          license
+          licenseUrl
+          url
+        }
+        name
+        slug {
+          fr
+          en
+        }
+      }
+    }
+  }
+}

package/src/runtime/graphql/queries/list/users.gql

@@ -0,0 +1,32 @@
+query listUsers(
+  $appId: ID = "iea"
+  $lang: String = "en"
+  $options: ListInput = {}
+) {
+  listUsers(appId: $appId, lang: $lang, options: $options) {
+    items {
+      admin
+      branch
+      createdAt
+      email
+      profile {
+        country
+        firstname
+        image
+        lastname
+        linkedin
+        position
+        presentation
+        references
+        twitter
+        wikipedia
+      }
+      role
+      settings {
+        lang
+      }
+      status
+    }
+    total
+  }
+}

package/src/runtime/plugins/pinia.ts

@@ -0,0 +1,88 @@
+import { createDynamicStore } from "../stores/factory"
+import type { AppConfig } from "nuxt/schema"
+import { useRootStore } from "../stores/root"
+const rootStore = useRootStore()
+export default defineNuxtPlugin(async (nuxtApp) => {
+  const appConfig = useAppConfig() as AppConfig & {
+    list: {
+      modules: string[]
+    }
+  }
+
+  // Define module imports
+  const moduleImports = {
+    events: () => ({
+      model: import("@paris-ias/data/dist/list/events.js"),
+      queries: {
+        list: import("@paris-ias/data/graphql/queries/list/events.gql"),
+        get: import("@paris-ias/data/graphql/queries/item/events.gql"),
+      },
+    }),
+    news: () => ({
+      model: import("@paris-ias/data/dist/list/news.js"),
+      queries: {
+        list: import("@paris-ias/data/graphql/queries/list/news.gql"),
+        get: import("@paris-ias/data/graphql/queries/item/news.gql"),
+      },
+    }),
+    people: () => ({
+      model: import("@paris-ias/data/dist/list/people.js"),
+      queries: {
+        list: import("@paris-ias/data/graphql/queries/list/people.gql"),
+        get: import("@paris-ias/data/graphql/queries/item/people.gql"),
+      },
+    }),
+    projects: () => ({
+      model: import("@paris-ias/data/dist/list/projects.js"),
+      queries: {
+        list: import("@paris-ias/data/graphql/queries/list/projects.gql"),
+        get: import("@paris-ias/data/graphql/queries/item/projects.gql"),
+      },
+    }),
+    fellowships: () => ({
+      model: import("@paris-ias/data/dist/list/fellowships.js"),
+      queries: {
+        list: import("@paris-ias/data/graphql/queries/list/fellowships.gql"),
+        get: import("@paris-ias/data/graphql/queries/item/fellowships.gql"),
+      },
+    }),
+    publications: () => ({
+      model: import("@paris-ias/data/dist/list/publications.js"),
+      queries: {
+        list: import("@paris-ias/data/graphql/queries/list/publications.gql"),
+        get: import("@paris-ias/data/graphql/queries/item/publications.gql"),
+      },
+    }),
+
+    // Add other modules similarly...
+  }
+
+  // Initialize empty stores object
+  const stores: Record<string, any> = {}
+  const queries = {}
+
+  // Preload all required modules
+  await Promise.all(
+    appConfig.list.modules.map(async (type) => {
+      try {
+        const imports = await moduleImports[
+          type as keyof typeof moduleImports
+        ]()
+        const model = (await imports.model).default
+        queries[type] = {
+          list: (await imports.queries.list).default,
+          get: (await imports.queries.get).default,
+        }
+
+        stores[type] = createDynamicStore(type, { ...model, queries })()
+      } catch (error) {
+        console.error(`Failed to initialize ${type} store:`, error)
+      }
+    })
+  )
+
+  // Provide synchronous access to stores and queries
+  nuxtApp.provide("rootStore", rootStore)
+  nuxtApp.provide("stores", stores)
+  nuxtApp.provide("queries", queries)
+})

package/src/runtime/plugins/vuetify.js

@@ -0,0 +1,21 @@
+import { createVuetify } from "vuetify"
+import * as components from "vuetify/components"
+import * as directives from "vuetify/directives"
+
+export default defineNuxtPlugin((nuxtApp) => {
+  const vuetify = createVuetify({
+    ssr: true,
+    components,
+    directives,
+    mobileBreakpoint: "sm",
+    /*  thresholds: {
+      xs: 0,
+      sm: 340,
+      md: 540,
+      lg: 800,
+      xl: 1280,
+    }, */
+  })
+
+  nuxtApp.vueApp.use(vuetify)
+})

package/src/runtime/stores/factory.ts

@@ -0,0 +1,18 @@
+export const createDynamicStore = (storeName: string, moduleState: object) => {
+  return defineStore(storeName, () => {
+    const state = reactive({
+      loading: false,
+      total: 0,
+      skip: 0,
+      page: 1,
+      numberOfPages: 0,
+      search: "",
+      error: null as string | null,
+      ...moduleState,
+    })
+
+    return {
+      ...toRefs(state),
+    }
+  })
+}

package/src/runtime/stores/root.ts

@@ -0,0 +1,353 @@
+/* import filtersRaw from '~/assets/data/filters'
+import lists from '~/assets/data/lists' */
+
+/* import api from "~/server/api/github" */
+import { defineStore } from "pinia"
+import type { Views, ModuleType } from "@paris-ias/data"
+
+import SEARCH from "../graphql/queries/list/search.gql"
+export const useRootStore = defineStore("rootStore", {
+  state: (): Record<
+    string,
+    boolean | number | string | ModuleType | searchResults
+  > => ({
+    scrolled: import.meta.browser ? window.scrollY > 0 : false,
+    loading: false,
+    total: 0,
+    skip: 0,
+    page: 1,
+    numberOfPages: 0,
+    search: "",
+    results: {
+      events: {},
+      news: {},
+      people: {},
+      projects: {},
+      fellowships: {},
+      publications: {},
+    },
+  }),
+
+  actions: {
+    setLoading(value: boolean, type: string = "") {
+      const { $stores } = useNuxtApp()
+      this.loading = value
+      if (type.length) $stores[type].loading = value
+    },
+    setScrolled() {
+      if (import.meta.browser) {
+        this.scrolled = window.scrollY > 0
+      }
+    },
+    loadRouteQuery(type: string) {
+      const { currentRoute } = useRouter()
+      const { $stores } = useNuxtApp()
+      const query = currentRoute.value.query
+      if (Object.keys(query)?.length) {
+        Object.keys(query).forEach((filter) => {
+          if (Object.keys($stores[type].filters).includes(filter))
+            $stores[type].filters[filter].value = (this[type] as ModuleType)
+              .list.filters[filter].multiple
+              ? JSON.parse(query[filter] as string)
+              : query[filter]
+        })
+        /*       if (query.view) {
+        ;$stores[type].view = query.view as
+          | string
+          | Views
+          | undefined
+      }
+      if (query.page) {
+        this.page = +query.page
+      } else {
+        this.page = 1
+      } */
+
+        /*      const sortObj = $stores[type].sort
+      const defaultSortKey = Object.keys(sortObj).find(
+        (item) => sortObj[item].default === true,
+      )
+      const defaultSort = [sortObj[defaultSortKey as string]]
+
+      const sortDesc = $stores[type].sortDesc
+      let sortDescItem
+      sortDescItem = (sortDesc as number[] | boolean[])[0]
+
+      if (query.sortBy) {
+        ;$stores[type].sortBy = [query.sortBy] as string[]
+      }
+      if (typeof query.sortDesc !== "undefined") {
+        sortDescItem = !!(query.sortDesc === "true")
+      } else {
+        sortDescItem = defaultSort[0].value[1]
+      } */
+      }
+      console.log("query loaded")
+    },
+
+    setFiltersCount(type: string) {
+      const { $stores } = useNuxtApp()
+      let filtersCount = 0 as number
+      Object.keys($stores[type].filters)
+        // remove empty values
+        .forEach((filter) => {
+          /*console.log("filter: ", filter)  
+          console.log("filters[filter]?.value: ", filters[filter].value)
+          */ /*  console.log(
+            'typeof filters[filter]?.value !== "undefined": ',
+            typeof filters[filter]?.value !== "undefined",
+          ) */
+          if (
+            $stores[type].filters[filter]?.value?.length &&
+            typeof $stores[type].filters[filter]?.value !== "undefined"
+          ) {
+            filtersCount++
+          }
+          return filtersCount
+        })
+
+      $stores[type].filtersCount = filtersCount
+    },
+    setBlankFilterLoad(type: string) {
+      /*  ;(this[type] as ModuleType).loading = false */
+    },
+    setDefaults() {
+      // lang
+      const lang = localStorage.getItem("lang")
+      /*    if(lang)i18n.global.locale = lang; */
+      // dark mode
+
+      // event
+      // people
+      // news
+      // project
+      // fellowships
+    },
+    updateRouteQuery(type: string) {
+      const router = useRouter()
+      const { $stores } = useNuxtApp()
+      // update route
+      const routeQuery: Record<string, string> = {
+        // Add search if it exists and is defined
+        ...(this.search ? { search: this.search } : {}),
+
+        // Add page if it's greater than 1
+        ...(this.page > 1 ? { page: this.page.toString() } : {}),
+
+        // Add filters with defined values
+        ...Object.entries($stores[type].filters).reduce(
+          (acc, [filterKey, filter]) => {
+            if (!$stores[type].filters[filterKey]?.value) {
+              return acc
+            }
+            return {
+              ...acc,
+              ...{
+                [filterKey]: $stores[type].filters[filterKey]?.value,
+              },
+            }
+          },
+          {} as Record<string, string>
+        ),
+      }
+      router.replace({ query: routeQuery })
+    },
+    resetState() {
+      const { $stores } = useNuxtApp()
+      console.log("resetState")
+      this.search = ""
+      this.page = 1
+      this.scrolled = false
+      this.loading = false
+      this.total = 0
+      this.skip = 0
+      this.numberOfPages = 0
+      const modules = [
+        "events",
+        "news",
+        "people",
+        "projects",
+        "fellowships",
+        "publications",
+      ]
+      /*       this.events.list.filters = events.list.filters
+      this.news.list.filters = news.list.filters
+      this.people.list.filters = people.list.filters
+      this.projects.list.filters = projects.list.filters
+      this.fellowships.list.filters = fellowships.list.filters
+      this.publications.list.filters = publications.list.filters */
+      modules.forEach((type) => {
+        /*  const viewsObj = $stores[type].views as Record<
+          string,
+          Views
+        >
+        const defaultViewsKey = Object.keys(viewsObj).find(
+          (item) => viewsObj[item].default === true
+        )
+        const defaultView = viewsObj[defaultViewsKey as string]
+
+        const sortObj = $stores[type].sort
+        const defaultSortKey = Object.keys(sortObj).find(
+          (item) => sortObj[item].default === true
+        )
+        const defaultSort = sortObj[defaultSortKey as string] */
+        /* 
+        // TODO make dynamic based on an ~/assets located file
+        ;$stores[type].view = defaultView
+        ;$stores[type].sortBy = [defaultSort.value[0]]
+        ;$stores[type].sortDesc = [defaultSort.value[1]] */
+      })
+    },
+    updateSort({ value, type }: { value: number[] | string[]; type: string }) {
+      const { $stores } = useNuxtApp()
+      $stores[type].sortBy = [value[0]] as string[]
+      $stores[type].sortDesc = [value[1]] as number[]
+      this.page = 1
+      this.updateLocalStorage(type + "_sort", value.join("_"))
+      this.update(type)
+    },
+    updateView({ value, type }: { value: string; type: string }) {
+      const { $stores } = useNuxtApp()
+      $stores[type].view = {
+        ...($stores[type].views[value] as Views),
+        name: value,
+      }
+      this.updateLocalStorage(type + "_view", value)
+      this.update(type)
+    },
+    updateLocalStorage(key: string, value: string) {
+      const local = JSON.parse(localStorage.getItem("PARIS_IAS") as any) || {}
+      local[key] = value
+      localStorage.setItem("PARIS_IAS", JSON.stringify(local))
+    },
+    updateFilter(key: string, val: any, type: string) {
+      const { $stores } = useNuxtApp()
+      console.log("update filter: ", { key, val, type })
+
+      if (["online", "outside", "past"].includes(key) && val === false) {
+        $stores[type].filters[key].value = null
+      } else {
+        $stores[type].filters[key].value = val
+      }
+
+      this.updatePage({ page: 1, type })
+    },
+    updateItemsPerPage({ value, type }: { value: number; type: string }) {
+      const { $stores } = useNuxtApp()
+      this.page = 1
+      $stores[types].itemsPerPage = value
+
+      this.update(type)
+    },
+    updatePage({ page, type }: { page: number; type: string }) {
+      this.page = page
+      this.update(type)
+    },
+    async updateSearch({
+      type = "all",
+      search = "",
+      lang = "en",
+    }: {
+      type: string
+      search: string
+      lang: string
+    }) {
+      this.search = search
+      /*   console.log("updateSearch: ", search + " " + lang) */
+      this.setLoading(true)
+
+      await this.update(type, lang)
+    },
+
+    async update(type: string, lang: string = "en") {
+      const { $stores } = useNuxtApp()
+      this.setLoading(true)
+      if (type !== "all") {
+        $stores[type].loading = true
+      }
+
+      // fetch the item categories
+
+      const itemsPerPage =
+        type === "all" ? 3 : ($stores[type]?.itemsPerPage as number)
+      const filters: Record<string, any> = {}
+
+      if (type !== "all") {
+        for (const filter in $stores[type].filters) {
+          const filterValue = $stores[type].filters[filter]?.value
+
+          // Prune empty values
+          if (typeof filterValue !== "undefined" && filterValue?.length) {
+            filters[filter] = filterValue
+          }
+        }
+      }
+
+      const args = JSON.parse(
+        JSON.stringify({
+          options: {
+            // skip
+            skip: +this.page === 1 ? 0 : (+this.page - 1) * itemsPerPage,
+            // limit
+            limit: itemsPerPage,
+            // sort, array of keys and array of directions - to have x tie breakers if necessary
+            sortBy: type === "all" ? "searchScore" : $stores[type].sortBy,
+            sortDesc:
+              type === "all" ? -1 : $stores[type].sortDesc > 0 ? true : false,
+            // search (if set)
+            ...((this.search as string)?.length &&
+              type !== "all" && { search: this.search }),
+            // add the store module filters
+            filters,
+          },
+          ...((this.search as string)?.length &&
+            type === "all" && { search: this.search }),
+          appId: "iea",
+          lang,
+        })
+      )
+      args.options.filters = JSON.stringify(args.options.filters)
+      let result: any = {}
+      console.log("args: ", args)
+
+      console.log(`Fetching ${type}`)
+      const { $queries } = useNuxtApp()
+      const { data, error } = await useAsyncQuery(
+        type === "all" ? SEARCH : $queries[type].list,
+        args
+      )
+      /*    console.log("data: ", data) */
+      if (error.value) console.log(error.value)
+      const key =
+        type === "all"
+          ? "search"
+          : "list" + type.charAt(0).toUpperCase() + type.slice(1)
+
+      if (type === "all") {
+        this.results = data?.value?.[key]
+      } else {
+        const items = data?.value?.[key]?.items ?? []
+        this.total = data?.value?.[key]?.total
+        result = {
+          ...data?.value?.[key],
+          items: items.map(({ id, ...rest }) => ({
+            ...rest,
+            _path: `/${id}`,
+          })),
+        }
+        $stores[type].items = result["items"]
+
+        const lastPage = Math.ceil(result.total / itemsPerPage)
+        /*         this.updateRouteQuery(type) */
+        this.setFiltersCount(type)
+        this.setBlankFilterLoad(type)
+        /*       console.log("type2: ", type) */
+        $stores[type].numberOfPages = lastPage
+      }
+      /*     console.log("this.total: ", this.total)
+       */
+      this.setLoading(false, type)
+      return true
+    },
+  },
+})