@open-commune/web 0.1.3

package/server/tasks/deploy.ts

@@ -0,0 +1,26 @@
+import { defineTask } from 'nitropack/runtime';
+import { DeployHookMissingError } from '@open-commune/core';
+import { useCore } from '../utils/core.ts';
+
+/**
+ * Triggers the site build. A failure surfaces as a task error rather than being
+ * reported as a success. A missing hook is an explicit no-op.
+ */
+export default defineTask({
+  meta: {
+    name: 'deploy',
+    description: 'Trigger the site build through the configured deploy hook',
+  },
+  async run(): Promise<{ result: { triggered: boolean; status?: number; reason?: string } }> {
+    const { services } = useCore();
+    try {
+      const { status } = await services.organization.deploy();
+      return { result: { triggered: true, status } };
+    } catch (error) {
+      if (error instanceof DeployHookMissingError) {
+        return { result: { triggered: false, reason: 'no deploy hook configured' } };
+      }
+      throw error;
+    }
+  },
+});

package/server/types.d.ts

@@ -0,0 +1,8 @@
+import type { AuthSession } from '@open-commune/core';
+
+declare module 'h3' {
+  interface H3EventContext {
+    /** Authenticated session (or null), resolved by middleware/2.session.ts. */
+    session: AuthSession | null;
+  }
+}

package/server/utils/core.ts

@@ -0,0 +1,18 @@
+import { createCore, type Core } from '@open-commune/core';
+
+/**
+ * The wired Core, as a singleton. `plugins/core.ts` makes the first call at
+ * server start, so migrations and housekeeping run at boot rather than on the
+ * first request.
+ */
+let core: Core | undefined;
+
+export function useCore(): Core {
+  if (!core) {
+    core = createCore();
+    // Boot housekeeping: SQLite has no TTL indexes, so expired rows are
+    // purged explicitly at start-up.
+    void core.services.users.purgeExpired();
+  }
+  return core;
+}

package/store/layout/headings.js

@@ -0,0 +1,21 @@
+import { defineStore } from 'pinia'
+
+export const useHeadingsStore = defineStore('layout/headings', () => {
+  // State
+  const headings = ref({
+    title: '',
+    description: '',
+    mainAction: ''
+  })
+
+  // Getters
+  const hasHeadings = computed(() => Object.values(headings.value).filter(val => !!val).length) 
+
+  // Actions
+  function updateHeadings({ title, description, mainAction }) {
+    Object.assign(headings.value, { title, description, mainAction })
+  }
+
+  return { headings, hasHeadings, updateHeadings }
+})
+

package/store/layout/modal.js

@@ -0,0 +1,80 @@
+import { defineStore } from 'pinia'
+
+const DEFAULT_FN = () => true
+
+export const useModalStore = defineStore('layout/modal', () => {
+  // State
+  const _display = ref(false)
+  const _attributes = ref([])
+  const _details = ref({})
+  const _record = ref({})
+  const _updateRecord = ref({})
+  const _onSubmit = ref(DEFAULT_FN)
+
+  // Getters
+  const isEditing = computed(() => Object.keys(_record.value).includes('_id'))
+  const display = computed(() => _display.value)
+  const attributes = computed(() => _attributes.value)
+  const record = computed(() => _record.value)
+  const updatedRecord = computed(() => _updateRecord.value)
+  const title = computed(() => _details.value?.title)
+  const subTitle = computed(() => _details.value?.subTitle)
+  const closeButton = computed(() => _details.value?.closeButton || 'Fermer')
+  const acceptButton = computed(() => _details.value?.acceptButton || 'Créer')
+
+  // Actions
+  function open(data = { details: {}, record: {}, attributes: [] }) {
+    _details.value = { ...data.details }
+    _record.value = { ...data.record }
+    _updateRecord.value = { ...data.record }
+    _attributes.value = [...data.attributes]
+    _onSubmit.value = data.onSubmit || DEFAULT_FN
+    _display.value = true
+  }
+  function close () {
+    _details.value = {}
+    _record.value = {}
+    _updateRecord.value = {}
+    _attributes.value = []
+    _onSubmit.value = DEFAULT_FN
+    _display.value = false
+  }
+  /**
+   * Ce que le FORMULAIRE a modifié — et lui seul. Il n'émet que les champs
+   * qu'on a touchés, jamais l'enregistrement entier : c'est un accumulateur
+   * de changements, pas une copie de la fiche.
+   */
+  function updateRecord(data) {
+    _updateRecord.value = data
+  }
+
+  /**
+   * L'enregistrement tel qu'il est APRÈS édition : la fiche d'origine, sur
+   * laquelle on repose les champs modifiés.
+   *
+   * Soumettre le seul accumulateur revenait à remplacer la fiche par sa
+   * fraction changée. Modifier l'état d'une étape sans toucher au reste la
+   * réduisait à { _id, status } : titre, description et contenu, jamais
+   * émis parce que jamais touchés, disparaissaient à l'enregistrement.
+   */
+  async function submit () {
+    await _onSubmit.value({ ..._record.value, ..._updateRecord.value })
+    close()
+  }
+
+  return {
+    isEditing,
+    display,
+    attributes,
+    record,
+    updateRecord,
+    title,
+    subTitle,
+    closeButton,
+    acceptButton,
+    open,
+    close,
+    submit
+  }
+})
+

package/store/layout/notifications.js

@@ -0,0 +1,52 @@
+import { defineStore } from 'pinia'
+
+export const useNotificationsStore = defineStore('layout/notifications', () => {
+  // State
+  const _notifications = ref([])
+
+  // Getters
+  const notifications = computed(() => _notifications.value)
+
+  // Actions
+  /**
+   * Adds a notification to the notifications array.
+   *
+   * @param {Object} notification - The notification object to add.
+   * @param {string} notification.title - The title of the notification.
+   * @param {string} notification.type - The type of notification (warning / error / info / default)
+   * @param {string} [notification.description] - Optional description of the notification.
+   * @param {string} [notification.icon] - Optional icon for the notification.
+   * @param {Boolean} [notification.closeButton] - Optional close button for the notification.
+   * @param {number} notification.timeout - The timeout duration for the notification.
+   * @param {Function} [notification.callback] - Optional callback function for the notification.
+   * @param {string} [notification.color] - Optional color for the notification.
+   *
+   * @returns {Object} - The added notification object.
+   */
+  function add(notification) {
+    console.log('[NOTIFICATION] - add', notification)
+    Object.assign(notification, { id: new Date().getTime().toString() })
+
+    const index = notifications.value.findIndex((n) => n.id === notification.id)
+    if (index === -1) {
+      notifications.value.push(notification)
+    }
+
+    return notification
+  }
+
+  function close (id) {
+    console.log('[NOTIFICATION] - close')
+    const index = notifications.value.findIndex((n) => n.id === id)
+    if (index >= 0) {
+      notifications.value.splice(index, 1)
+    }
+  }
+
+  return {
+    notifications,
+    add,
+    close,
+  }
+})
+

package/store/layout/workspace.js

@@ -0,0 +1,80 @@
+import { defineStore } from 'pinia'
+
+// Single-tenant : les permissions dérivent du rôle Commun de l'utilisateur.
+// `manage:all` est un joker CASL (toute action sur tout sujet).
+//
+// `redacteur` reprend EXACTEMENT le rôle legacy « Éditeur de contenu », que
+// portaient tous les agents des collectivités. La première version n'avait
+// retenu que les records : les agents perdaient la publication du site, la
+// médiathèque et la lecture des collections — le bouton « Publier » avait donc
+// disparu pour tous sauf les comptes admin.
+const ROLE_PERMISSIONS = {
+  admin: ['manage:all'],
+  redacteur: [
+    'entrance:self',
+    'read:organizations',
+    'read:collections',
+    'read:records',
+    'create:records',
+    'update:records',
+    'delete:records',
+    'publish:records',
+    'read:media',
+    'create:media',
+    'update:media',
+    'delete:media',
+    'read:deployments',
+    'create:deployments'
+  ]
+}
+
+export const useWorkspaceStore = defineStore('layout/workspace', () => {
+  const $session = useSession()
+  const $models = useModels()
+  const $abilities = useAbility()
+
+  // State
+  const organization = ref(undefined)
+
+  // Getters
+  const workspace = computed(() => organization.value)
+  const workspaceId = computed(() => organization.value?._id)
+  const workspaceName = computed(() => organization.value?.name)
+  const workspacePath = computed(() => organization.value?.path)
+  const workspaceLogo = computed(() => organization.value?.logo)
+  const workspaceSettings = computed(() => organization.value?.settings)
+  const workspaceCollections = computed(() => organization.value?.collections)
+
+  // Actions
+  function updateAbilities() {
+    const user = $session.user.value
+    $abilities.assignAbilities([
+      'entrance:self',
+      ...(ROLE_PERMISSIONS[user?.role] ?? [])
+    ])
+  }
+
+  async function updateOrganization(selectedOrganization) {
+    if (selectedOrganization) {
+      organization.value = selectedOrganization
+      await Promise.all([
+        $models.Record.list('labels', organization.value._id, { limit: 100 }),
+        $models.Collection.list(),
+        updateAbilities()
+      ])
+    }
+  }
+
+  return {
+    organization,
+    workspace,
+    workspaceId,
+    workspaceName,
+    workspacePath,
+    workspaceLogo,
+    workspaceSettings,
+    workspaceCollections,
+    updateOrganization,
+    updateAbilities,
+  }
+})