@open-commune/web 0.1.3

package/models/collection.js

@@ -0,0 +1,87 @@
+// Collection Model
+import { Model } from 'pinia-orm'
+import ModelAPI from '~/models/_factory'
+import {
+  attributeToField,
+  definitionToCollection,
+  invalidateDefinitions
+} from '~/models/_commun'
+
+const _collectionModel = class Collection extends Model {
+  // This is the name used as module name of the Vuex Store.
+  static entity = 'Collection'
+  static primaryKey = '_id'
+
+  // List of all fields (schema) of the post model. `this.attr` is used
+  // for the generic field type. The argument is the default value.
+  static fields () {
+    return {
+      _id: this.attr(null),
+      name: this.attr(''),
+      slug: this.attr(''),
+      description: this.attr(''),
+      headings: this.attr({}),
+      display: this.attr({}),
+      editor: this.attr({}),
+      attributes: this.attr([]),
+      organization: this.attr(''),
+      createdBy: this.attr({}),
+      updatedBy: this.attr({}),
+      createdAt: this.attr(0),
+      updatedAt: this.attr(0)
+    }
+  }
+}
+
+/** collection legacy (attributes[]) → payload collections.create/update. */
+function toDefinitionPayload(record) {
+  const payload = {}
+  for (const key of ['name', 'slug', 'description', 'editor', 'display', 'headings']) {
+    if (record[key] !== undefined) payload[key] = record[key]
+  }
+  if (Array.isArray(record.attributes)) {
+    payload.fields = record.attributes.map(attributeToField).filter(Boolean)
+  }
+  return payload
+}
+
+const _collectionAPI = class CollectionAPI extends ModelAPI {
+  async list() {
+    const definitions = await this.trpc.collections.list.query()
+    this.repo.save(definitions.map(definitionToCollection))
+    return this.repo.query().all()
+  }
+
+  async read(_id) {
+    const definition = await this.trpc.collections.get.query({ idOrSlug: _id })
+    const collection = definitionToCollection(definition)
+    this.repo.save(collection)
+    return this.repo.find(collection._id)
+  }
+
+  async create(record) {
+    const definition = await this.trpc.collections.create.mutate(toDefinitionPayload(record))
+    invalidateDefinitions()
+    const collection = definitionToCollection(definition)
+    this.repo.save(collection)
+    return this.repo.find(collection._id)
+  }
+
+  async update(_id, record) {
+    const definition = await this.trpc.collections.update.mutate({
+      id: _id,
+      data: toDefinitionPayload(record)
+    })
+    invalidateDefinitions()
+    this.repo.save(definitionToCollection(definition))
+    return this.repo.find(_id)
+  }
+
+  async remove(_id) {
+    await this.trpc.collections.remove.mutate({ id: _id })
+    invalidateDefinitions()
+    return this.repo.destroy(_id)
+  }
+}
+
+export default { model: _collectionModel, api: _collectionAPI }

package/models/entrance.js

@@ -0,0 +1,42 @@
+// Entrance Model
+import { Model } from 'pinia-orm'
+import ModelAPI from '~/models/_factory'
+
+const _entranceModel = class Entrance extends Model {
+  // This is the name used as module name of the Vuex Store.
+  static entity = 'Entrance'
+  static primaryKey = '_id'
+
+  // List of all fields (schema) of the post model. `this.attr` is used
+  // for the generic field type. The argument is the default value.
+  static fields () {
+    return {}
+  }
+}
+
+const _entranceAPI = class EntranceAPI extends ModelAPI {
+  /**
+   * Le flux legacy confirm-email → define-password est remplacé par
+   * l'acceptation d'invitation Commun (une seule étape, publique).
+   */
+  async acceptInvitation({ token, name, password }) {
+    return this.trpc.auth.acceptInvitation.mutate({ token, name, password })
+  }
+
+  /** Mot de passe oublié (9.9) : réponse toujours ok (pas d'énumération). */
+  async recoverPassword(emailAddress) {
+    return this.trpc.auth.requestPasswordReset.mutate({ email: emailAddress })
+  }
+
+  /** Le lien du mail de reset pointe sur /password/define/<token> — même
+   * acceptation d'invitation, sans nom (conservé côté serveur). */
+  async updatePassword({ token, password }) {
+    return this.trpc.auth.acceptInvitation.mutate({ token, password })
+  }
+
+  async confirmEmail() {
+    throw new Error('E_NOT_AVAILABLE_YET')
+  }
+}
+
+export default { model: _entranceModel, api: _entranceAPI }

package/models/media.js

@@ -0,0 +1,82 @@
+// Media Model
+import { Model } from 'pinia-orm'
+import ModelAPI from '~/models/_factory'
+import { mediaToLegacy } from '~/models/_commun'
+
+const _mediaModel = class Media extends Model {
+  // This is the name used as module name of the Vuex Store.
+  static entity = 'Media'
+  static primaryKey = '_id'
+
+  // List of all fields (schema) of the post model. `this.attr` is used
+  // for the generic field type. The argument is the default value.
+  static fields () {
+    return {
+      _id: this.attr(null),
+      originalName: this.attr(''),
+      mime: this.attr(''),
+      objects: this.attr({}),
+      organization: this.attr(''),
+      createdBy: this.attr(''),
+      updatedBy: this.attr(''),
+      createdAt: this.attr(0),
+      updatedAt: this.attr(0)
+    }
+  }
+}
+
+const _mediaAPI = class MediaAPI extends ModelAPI {
+  async list() {
+    throw new Error('E_UNKNOWN_ENDPOINT')
+  }
+
+  /**
+   * Flux presigned iso legacy en 2 temps : requestUpload rend { key, url } —
+   * la clé S3 joue le rôle du `_id` transitoire que create() (finalize)
+   * transmet ensuite.
+   */
+  async getS3PreSignedUrl(media) {
+    const { key, url } = await this.trpc.media.requestUpload.mutate({
+      filename: media.name || 'fichier',
+      mime: media.mime
+    })
+    return { _id: key, url }
+  }
+
+  async create(record) {
+    const media = await this.trpc.media.finalize.mutate({
+      key: record._id,
+      filename: record.name || 'fichier',
+      mime: record.mime
+    })
+    // Relecture résolue : objects doit contenir les URLs signées, pas les clés.
+    const resolved = await this.trpc.media.get.query({ id: media.id })
+    const legacy = mediaToLegacy(resolved)
+    this.repo.save(legacy)
+    return this.repo.find(legacy._id)
+  }
+
+  async read(_id) {
+    const resolved = await this.trpc.media.get.query({ id: _id })
+    const legacy = mediaToLegacy(resolved)
+    this.repo.save(legacy)
+    return this.repo.find(legacy._id)
+  }
+
+  async update(_id, record) {
+    const data = {}
+    if (record.alt !== undefined) data.alt = record.alt
+    if (record.caption !== undefined) data.caption = record.caption
+    if (record.originalName !== undefined) data.filename = record.originalName
+    const media = await this.trpc.media.update.mutate({ id: _id, data })
+    this.repo.save(mediaToLegacy(media))
+    return this.repo.find(_id)
+  }
+
+  async remove(_id) {
+    await this.trpc.media.remove.mutate({ id: _id })
+    return this.repo.destroy(_id)
+  }
+}
+
+export default { model: _mediaModel, api: _mediaAPI }

package/models/organization.js

@@ -0,0 +1,92 @@
+// Organization Model
+import { Model } from 'pinia-orm'
+import ModelAPI from '~/models/_factory'
+
+const _organizationModel = class Organization extends Model {
+  // This is the name used as module name of the Vuex Store.
+  static entity = 'Organization'
+  static primaryKey = '_id'
+
+  // List of all fields (schema) of the post model. `this.attr` is used
+  // for the generic field type. The argument is the default value.
+  static fields () {
+    return {
+      _id: this.attr(''),
+      logo: this.attr(null),
+      name: this.attr(''),
+      slug: this.attr(''),
+      type: this.attr(''),
+      path: this.attr(''),
+      location: this.attr({}),
+      settings: this.attr({}),
+      injector: this.attr({}),
+      deployment: this.attr({}),
+      collections: this.attr([]),
+      directParent: this.attr({}),
+      createdBy: this.attr({}),
+      updatedBy: this.attr({}),
+      createdAt: this.attr(0),
+      updatedAt: this.attr(0)
+    }
+  }
+}
+
+
+// Clés du modèle Commun (revue 28/07 : address JSON, colonnes retirées).
+const UPDATABLE = ['name', 'type', 'slug', 'description', 'address', 'deployment', 'settings']
+
+const _organizationAPI = class OrganizationAPI extends ModelAPI {
+  /** Organization Commun (singleton) → organisation legacy, _id = slug (routes). */
+  async _toLegacy(organization) {
+    const definitions = await this.trpc.collections.list.query()
+    return {
+      _id: organization.slug,
+      name: organization.name,
+      slug: organization.slug,
+      type: organization.type,
+      path: `/${organization.slug}`,
+      logo: organization.settings?.logo ?? null,
+      location: {},
+      settings: organization.settings ?? {},
+      injector: {},
+      deployment: organization.deployment ?? {},
+      // Single-tenant : toutes les collections sont « actives ».
+      collections: definitions.map((definition) => definition.id),
+      directParent: {},
+      createdAt: organization.createdAt,
+      updatedAt: organization.updatedAt
+    }
+  }
+
+  async list() {
+    const organization = await this.trpc.organization.get.query()
+    if (!organization) return []
+    this.repo.save(await this._toLegacy(organization))
+    return this.repo.query().all()
+  }
+
+  async update(_id, record) {
+    const payload = {}
+    for (const key of UPDATABLE) {
+      if (record[key] !== undefined) payload[key] = record[key]
+    }
+    // Ex : toggle d'usage des collections (multi-tenant) → sans objet ici.
+    if (!Object.keys(payload).length) return this.repo.find(_id)
+    const organization = await this.trpc.organization.update.mutate(payload)
+    this.repo.save(await this._toLegacy(organization))
+    return this.repo.find(_id)
+  }
+
+  /** Bouton Publier : déclenche le build Vercel via l'API (tâche deploy). */
+  async createDeployment() {
+    return this.trpc.organization.deploy.mutate()
+  }
+
+  // L'état du déploiement Vercel n'est plus interrogé (le legacy sondait
+  // l'API Vercel) : le hook déclenché, le build part — polling neutre.
+  async getDeployment() {
+    return { state: 'READY' }
+  }
+}
+
+export default { model: _organizationModel, api: _organizationAPI }

package/models/record.js

@@ -0,0 +1,165 @@
+// Record Model
+import { Model } from "pinia-orm";
+import ModelAPI from "~/models/_factory";
+import {
+  entryToRecord,
+  getDefinition,
+  getUsersById,
+  toServerValue,
+} from "~/models/_commun";
+
+const _recordModel = class Record extends Model {
+  // This is the name used as module name of the Vuex Store.
+  static entity = "Record";
+  static primaryKey = "_id";
+
+  // List of all fields (schema) of the post model. `this.attr` is used
+  // for the generic field type. The argument is the default value.
+  static fields() {
+    return {
+      _id: this.attr(null),
+      title: this.attr(""),
+      slug: this.attr(""),
+      path: this.attr(""),
+      status: this.attr(""),
+      relatedCollection: this.attr(""),
+      records: this.attr([]),
+      attributes: this.attr([]),
+      createdBy: this.attr({}),
+      updatedBy: this.attr({}),
+      publishedAt: this.attr(""),
+      createdAt: this.attr(""),
+      updatedAt: this.attr(""),
+    };
+  }
+
+  static onRetrieve(data) {
+    const { attributes = [], ...rest } = data || {};
+
+    return {
+      ...attributes.reduce(
+        (acc = {}, { name, value }) => Object.assign(acc, { [name]: value }),
+        {},
+      ),
+      ...rest,
+    };
+  }
+
+  static onSave(data) {
+    const { title, status, records, ...attributes } = data || {};
+
+    return {
+      title,
+      status,
+      records,
+      attributes: Object.keys(attributes).length
+        ? Object.entries(attributes).map(([name, value]) => ({ name, value }))
+        : undefined,
+    };
+  }
+};
+
+// Le serveur borne entries.list à 100 par page — les appels legacy montaient
+// à 500 (select-record) : on pagine pour honorer la limite demandée.
+const PAGE_MAX = 100;
+
+const _recordAPI = class RecordAPI extends ModelAPI {
+  /**
+   * record aplati → payload entries.* : seuls les champs DÉFINIS par la
+   * collection alimentent `data` (les colonnes document _id/slug/path/…
+   * renvoyées par onSave sont ignorées, iso legacy). `records[]` (liens
+   * libres de l'onglet Relations) part en `related` — le serveur entretient
+   * la symétrie des liens inverses (upgrade-admin-nuxt4).
+   */
+  async _payload(record, collection) {
+    const definition = await getDefinition(this.trpc, collection);
+    const fieldsByName = new Map(
+      definition.fields.map((field) => [field.name, field]),
+    );
+    const { title, status, records, attributes = [] } = this.onSave(record);
+
+    const data = {};
+    for (const { name, value } of attributes ?? []) {
+      const field = fieldsByName.get(name);
+      if (!field) continue;
+      data[name] = toServerValue(field, value);
+    }
+
+    const payload = {};
+    if (title !== undefined) payload.title = title;
+    if (status) payload.status = status;
+    if (Object.keys(data).length) payload.data = data;
+    if (Array.isArray(records)) payload.related = records;
+    return { definition, payload };
+  }
+
+  async read(_id, collection) {
+    const definition = await getDefinition(this.trpc, collection);
+    const [entry, usersById] = await Promise.all([
+      this.trpc.collections.entries.get.query({ id: _id }),
+      getUsersById(this.trpc),
+    ]);
+    this.repo.save(entryToRecord(definition, entry, usersById));
+    return this.repo.find(_id);
+  }
+
+  async list(collection, organizationId, queryParams = {}) {
+    // Une collection absente ne casse pas la page (iso legacy : liste vide).
+    const definition = await getDefinition(this.trpc, collection).catch(
+      () => null,
+    );
+    if (!definition) return this.repo.query().all();
+
+    const skip = Number(queryParams.skip ?? 0);
+    const wanted = Number(queryParams.limit ?? 20);
+    const entries = [];
+    while (entries.length < wanted) {
+      const size = Math.min(wanted - entries.length, PAGE_MAX);
+      const page = await this.trpc.collections.entries.list.query({
+        collectionId: definition.id,
+        skip: skip + entries.length,
+        limit: size,
+      });
+      entries.push(...page);
+      if (page.length < size) break;
+    }
+
+    const usersById = await getUsersById(this.trpc);
+    const records = entries.map((entry) => entryToRecord(definition, entry, usersById));
+    if (queryParams?.skip !== 0) {
+      this.repo.save(records);
+    } else {
+      this.repo.fresh(records);
+    }
+    return this.repo.query().all();
+  }
+
+  async create(record, collection) {
+    const { definition, payload } = await this._payload(record, collection);
+    const entry = await this.trpc.collections.entries.create.mutate({
+      collectionId: definition.id,
+      // `data` est requis à la création (le slug est généré serveur, iso legacy).
+      data: { status: "draft", ...payload, data: payload.data ?? {} },
+    });
+    const saved = entryToRecord(definition, entry, await getUsersById(this.trpc));
+    this.repo.save(saved);
+    return this.repo.find(saved._id);
+  }
+
+  async update(_id, record, collection) {
+    const { definition, payload } = await this._payload(record, collection);
+    const entry = await this.trpc.collections.entries.update.mutate({
+      id: _id,
+      data: payload,
+    });
+    this.repo.save(entryToRecord(definition, entry, await getUsersById(this.trpc)));
+    return this.repo.find(_id);
+  }
+
+  async remove(_id) {
+    await this.trpc.collections.entries.remove.mutate({ id: _id });
+    return this.repo.destroy(_id);
+  }
+};
+
+export default { model: _recordModel, api: _recordAPI };

package/models/role.js

@@ -0,0 +1,66 @@
+// Role Model
+import { Model } from 'pinia-orm'
+import ModelAPI from '~/models/_factory'
+
+const _roleModel = class Role extends Model {
+  // This is the name used as module name of the Vuex Store.
+  static entity = 'Role'
+  static primaryKey = '_id'
+
+  // List of all fields (schema) of the post model. `this.attr` is used
+  // for the generic field type. The argument is the default value.
+  static fields () {
+    return {
+      _id: this.attr(null),
+      name: this.attr(''),
+      description: this.attr(''),
+      permissions: this.attr([]),
+      onlyOwn: this.attr(false),
+      mfa: this.attr(false),
+      createdBy: this.attr({}),
+      updatedBy: this.attr({}),
+      createdAt: this.attr(0),
+      updatedAt: this.attr(0)
+    }
+  }
+}
+
+/**
+ * Les rôles paramétrables du legacy sont remplacés par le modèle fixe Commun
+ * (admin / redacteur). La liste est statique ; le CRUD est inerte.
+ */
+const ROLES = [
+  {
+    _id: 'admin',
+    name: 'Administrateur',
+    description: 'Accès complet : contenus, médias, membres et réglages.',
+    permissions: ['manage:all']
+  },
+  {
+    _id: 'redacteur',
+    name: 'Rédacteur',
+    description: 'Gestion des contenus et des médias.',
+    permissions: ['entrance:self', 'read:records', 'create:records', 'update:records', 'delete:records']
+  }
+]
+
+const _roleAPI = class RoleAPI extends ModelAPI {
+  async list() {
+    this.repo.save(ROLES)
+    return this.repo.query().all()
+  }
+
+  async create() {
+    throw new Error('E_ROLES_FIXED')
+  }
+
+  async update() {
+    throw new Error('E_ROLES_FIXED')
+  }
+
+  async remove() {
+    throw new Error('E_ROLES_FIXED')
+  }
+}
+
+export default { model: _roleModel, api: _roleAPI }

package/models/token.js

@@ -0,0 +1,56 @@
+// Token Model
+import { Model } from 'pinia-orm'
+import ModelAPI from '~/models/_factory'
+
+const _tokenModel = class Token extends Model {
+  // This is the name used as module name of the Vuex Store.
+  static entity = 'Token'
+  static primaryKey = '_id'
+
+  // List of all fields (schema) of the post model. `this.attr` is used
+  // for the generic field type. The argument is the default value.
+  static fields () {
+    return {
+      _id: this.attr(null),
+      name: this.attr(''),
+      token: this.attr(''),
+      lastEntrance: this.attr(0),
+      organization: this.attr({}),
+      createdBy: this.attr({}),
+      createdAt: this.attr(0),
+      updatedAt: this.attr(0)
+    }
+  }
+}
+
+const _tokenAPI = class TokenAPI extends ModelAPI {
+  async list() {
+    const tokens = await this.trpc.apiTokens.list.query()
+    // Les tokens sont désormais stockés hachés : la valeur en clair n'est
+    // visible qu'à la création (différence assumée vs legacy plaintext).
+    this.repo.save(
+      tokens
+        .filter((token) => !token.revokedAt)
+        .map((token) => ({
+          _id: token.id,
+          name: token.name,
+          lastEntrance: token.lastUsedAt ?? 0,
+          createdAt: token.createdAt
+        }))
+    )
+    return this.repo.query().all()
+  }
+
+  async create(record) {
+    const created = await this.trpc.apiTokens.create.mutate({ name: record.name })
+    this.repo.save({ _id: created.id, name: created.name, token: created.token })
+    return this.repo.find(created.id)
+  }
+
+  async remove(_id) {
+    await this.trpc.apiTokens.revoke.mutate({ id: _id })
+    return this.repo.destroy(_id)
+  }
+}
+
+export default { model: _tokenModel, api: _tokenAPI }

package/models/user.js

@@ -0,0 +1,97 @@
+// User Model
+import { Model } from 'pinia-orm'
+import ModelAPI from '~/models/_factory'
+
+const _userModel = class User extends Model {
+  // This is the name used as module name of the Vuex Store.
+  static entity = 'User'
+  static primaryKey = '_id'
+
+  // List of all fields (schema) of the post model. `this.attr` is used
+  // for the generic field type. The argument is the default value.
+  static fields () {
+    return {
+      _id: this.attr(null),
+      firstName: this.attr(''),
+      lastName: this.attr(''),
+      phone: this.attr(''),
+      emailAddress: this.attr(''),
+      emailStatus: this.attr(''),
+      emailChangeCandidate: this.attr(''),
+      avatar: this.attr({}),
+      role: this.attr(''),
+      organizations: this.attr([]),
+      permissions: this.attr([]),
+      createdBy: this.attr({}),
+      updatedBy: this.attr({}),
+      createdAt: this.attr(0),
+      updatedAt: this.attr(0)
+    }
+  }
+
+  /**
+   * Get full name of the user.
+   */
+  get fullName () {
+    return [this.firstName, this.lastName].join(' ')
+  }
+}
+
+/** PublicUser Commun { id, email, name, role } → user legacy. */
+function userToLegacy(user) {
+  return {
+    _id: user.id,
+    firstName: user.name ?? '',
+    lastName: '',
+    emailAddress: user.email,
+    emailStatus: 'confirmed',
+    role: user.role,
+    organizations: [],
+    permissions: []
+  }
+}
+
+const _userAPI = class UserAPI extends ModelAPI {
+  async list() {
+    const users = await this.trpc.users.list.query()
+    this.repo.save(users.map(userToLegacy))
+    return this.repo.query().all()
+  }
+
+  async read(_id) {
+    const user = await this.trpc.users.get.query({ id: _id })
+    this.repo.save(userToLegacy(user))
+    return this.repo.find(_id)
+  }
+
+  /**
+   * La création directe n'existe plus : on émet une INVITATION (le lien est
+   * affiché à l'admin tant que l'envoi de mails — tâche 9.9 — n'est pas porté).
+   * Retourne { token, expiresAt } en plus de rafraîchir la liste.
+   */
+  async create(record) {
+    const invitation = await this.trpc.users.invite.mutate({
+      email: record.emailAddress,
+      role: record.role || 'redacteur'
+    })
+    return invitation
+  }
+
+  async update(_id, record) {
+    const data = {}
+    if (record.firstName !== undefined || record.lastName !== undefined) {
+      data.name = [record.firstName, record.lastName].filter(Boolean).join(' ')
+    }
+    if (record.role !== undefined) data.role = record.role
+    const user = await this.trpc.users.update.mutate({ id: _id, data })
+    this.repo.save(userToLegacy(user))
+    return this.repo.find(_id)
+  }
+
+  async remove(_id) {
+    await this.trpc.users.remove.mutate({ id: _id })
+    return this.repo.destroy(_id)
+  }
+}
+
+export default { model: _userModel, api: _userAPI }