@interware/content-generator 0.7.2 → 0.8.0

package/dist/server/src/bootstrap.d.ts

@@ -1,6 +1,8 @@
 import type { Core } from '@strapi/strapi';
 /** Tarea que publica los artículos programados (E6, D4). */
 export declare const SCHEDULE_CRON = "content-generator-publicar-programados";
+/** Ciclo de la sincronización con Google Drive (E7, S7.3). */
+export declare const DRIVE_CRON = "content-generator-drive";
 declare const bootstrap: ({ strapi }: {
     strapi: Core.Strapi;
 }) => Promise<void>;

package/dist/server/src/content-types/drive-link/index.d.ts

@@ -0,0 +1,62 @@
+declare const _default: {
+    schema: {
+        kind: string;
+        collectionName: string;
+        info: {
+            singularName: string;
+            pluralName: string;
+            displayName: string;
+            description: string;
+        };
+        options: {
+            draftAndPublish: boolean;
+        };
+        pluginOptions: {
+            'content-manager': {
+                visible: boolean;
+            };
+            'content-type-builder': {
+                visible: boolean;
+            };
+        };
+        attributes: {
+            cmsType: {
+                type: string;
+                enum: string[];
+                required: boolean;
+            };
+            cmsId: {
+                type: string;
+                required: boolean;
+            };
+            driveId: {
+                type: string;
+            };
+            root: {
+                type: string;
+                default: boolean;
+            };
+            name: {
+                type: string;
+            };
+            parentCmsId: {
+                type: string;
+            };
+            version: {
+                type: string;
+            };
+            driveRev: {
+                type: string;
+            };
+            status: {
+                type: string;
+                enum: string[];
+                default: string;
+            };
+            error: {
+                type: string;
+            };
+        };
+    };
+};
+export default _default;

package/dist/server/src/content-types/drive-link/schema.d.ts

@@ -0,0 +1,68 @@
+/**
+ * Vínculo entre un archivo o carpeta de la Biblioteca y su par en Drive (ADR-010, S7.3). Solo existe para lo
+ * sincronizado. Oculto en Content Manager y en Content-Type Builder, como `template`.
+ */
+declare const _default: {
+    kind: string;
+    collectionName: string;
+    info: {
+        singularName: string;
+        pluralName: string;
+        displayName: string;
+        description: string;
+    };
+    options: {
+        draftAndPublish: boolean;
+    };
+    pluginOptions: {
+        'content-manager': {
+            visible: boolean;
+        };
+        'content-type-builder': {
+            visible: boolean;
+        };
+    };
+    attributes: {
+        cmsType: {
+            type: string;
+            enum: string[];
+            required: boolean;
+        };
+        cmsId: {
+            type: string;
+            required: boolean;
+        };
+        /** Vacío mientras el archivo espera su primera subida. */
+        driveId: {
+            type: string;
+        };
+        /** Lo marcó el usuario; los demás vínculos son contenido o ancestros de algo marcado. */
+        root: {
+            type: string;
+            default: boolean;
+        };
+        name: {
+            type: string;
+        };
+        parentCmsId: {
+            type: string;
+        };
+        /** Archivo: `url|size` de la última subida. */
+        version: {
+            type: string;
+        };
+        /** `md5Checksum` de Drive de la última versión sincronizada (S7.4). */
+        driveRev: {
+            type: string;
+        };
+        status: {
+            type: string;
+            enum: string[];
+            default: string;
+        };
+        error: {
+            type: string;
+        };
+    };
+};
+export default _default;

package/dist/server/src/content-types/drive-op/index.d.ts

@@ -0,0 +1,46 @@
+declare const _default: {
+    schema: {
+        kind: string;
+        collectionName: string;
+        info: {
+            singularName: string;
+            pluralName: string;
+            displayName: string;
+            description: string;
+        };
+        options: {
+            draftAndPublish: boolean;
+        };
+        pluginOptions: {
+            'content-manager': {
+                visible: boolean;
+            };
+            'content-type-builder': {
+                visible: boolean;
+            };
+        };
+        attributes: {
+            cmsType: {
+                type: string;
+                enum: string[];
+                required: boolean;
+            };
+            cmsId: {
+                type: string;
+                required: boolean;
+            };
+            attempts: {
+                type: string;
+                default: number;
+            };
+            runAfter: {
+                type: string;
+                default: string;
+            };
+            error: {
+                type: string;
+            };
+        };
+    };
+};
+export default _default;

package/dist/server/src/content-types/drive-op/schema.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Cola de la sincronización con Drive (ADR-009, S7.3): «revisa este elemento». Qué hacer se decide al
+ * procesar, comparando contra su vínculo; encolar dos veces no cambia el resultado.
+ */
+declare const _default: {
+    kind: string;
+    collectionName: string;
+    info: {
+        singularName: string;
+        pluralName: string;
+        displayName: string;
+        description: string;
+    };
+    options: {
+        draftAndPublish: boolean;
+    };
+    pluginOptions: {
+        'content-manager': {
+            visible: boolean;
+        };
+        'content-type-builder': {
+            visible: boolean;
+        };
+    };
+    attributes: {
+        cmsType: {
+            type: string;
+            enum: string[];
+            required: boolean;
+        };
+        cmsId: {
+            type: string;
+            required: boolean;
+        };
+        attempts: {
+            type: string;
+            default: number;
+        };
+        /** Epoch en ms: no se procesa antes (espera creciente tras un error). */
+        runAfter: {
+            type: string;
+            default: string;
+        };
+        error: {
+            type: string;
+        };
+    };
+};
+export default _default;

package/dist/server/src/content-types/index.d.ts

@@ -63,5 +63,111 @@ declare const _default: {
             };
         };
     };
+    'drive-link': {
+        schema: {
+            kind: string;
+            collectionName: string;
+            info: {
+                singularName: string;
+                pluralName: string;
+                displayName: string;
+                description: string;
+            };
+            options: {
+                draftAndPublish: boolean;
+            };
+            pluginOptions: {
+                'content-manager': {
+                    visible: boolean;
+                };
+                'content-type-builder': {
+                    visible: boolean;
+                };
+            };
+            attributes: {
+                cmsType: {
+                    type: string;
+                    enum: string[];
+                    required: boolean;
+                };
+                cmsId: {
+                    type: string;
+                    required: boolean;
+                };
+                driveId: {
+                    type: string;
+                };
+                root: {
+                    type: string;
+                    default: boolean;
+                };
+                name: {
+                    type: string;
+                };
+                parentCmsId: {
+                    type: string;
+                };
+                version: {
+                    type: string;
+                };
+                driveRev: {
+                    type: string;
+                };
+                status: {
+                    type: string;
+                    enum: string[];
+                    default: string;
+                };
+                error: {
+                    type: string;
+                };
+            };
+        };
+    };
+    'drive-op': {
+        schema: {
+            kind: string;
+            collectionName: string;
+            info: {
+                singularName: string;
+                pluralName: string;
+                displayName: string;
+                description: string;
+            };
+            options: {
+                draftAndPublish: boolean;
+            };
+            pluginOptions: {
+                'content-manager': {
+                    visible: boolean;
+                };
+                'content-type-builder': {
+                    visible: boolean;
+                };
+            };
+            attributes: {
+                cmsType: {
+                    type: string;
+                    enum: string[];
+                    required: boolean;
+                };
+                cmsId: {
+                    type: string;
+                    required: boolean;
+                };
+                attempts: {
+                    type: string;
+                    default: number;
+                };
+                runAfter: {
+                    type: string;
+                    default: string;
+                };
+                error: {
+                    type: string;
+                };
+            };
+        };
+    };
 };
 export default _default;

package/dist/server/src/controllers/drive.d.ts

@@ -0,0 +1,30 @@
+import type { Core } from '@strapi/strapi';
+type Ctx = {
+    request: {
+        body?: Record<string, unknown>;
+    };
+    query: Record<string, unknown>;
+    params?: Record<string, string>;
+    status: number;
+    body: unknown;
+};
+/** Rutas de la conexión con Google Drive (S7.1): 400 entrada inválida, 500 el resto. */
+declare const _default: ({ strapi }: {
+    strapi: Core.Strapi;
+}) => {
+    status: (ctx: Ctx) => Promise<void>;
+    saveClient: (ctx: Ctx) => Promise<void>;
+    removeClient: (ctx: Ctx) => Promise<void>;
+    authorizationUrl: (ctx: Ctx) => Promise<void>;
+    exchange: (ctx: Ctx) => Promise<void>;
+    disconnect: (ctx: Ctx) => Promise<void>;
+    links: (ctx: Ctx) => Promise<void>;
+    mark: (ctx: Ctx) => Promise<void>;
+    unmark: (ctx: Ctx) => Promise<void>;
+    syncNow: (ctx: Ctx) => Promise<void>;
+    browse: (ctx: Ctx) => Promise<void>;
+    count: (ctx: Ctx) => Promise<void>;
+    trash: (ctx: Ctx) => Promise<void>;
+    origin: (ctx: Ctx) => Promise<void>;
+};
+export default _default;

package/dist/server/src/controllers/index.d.ts

@@ -143,6 +143,136 @@ declare const _default: {
             body: unknown;
         }) => Promise<void>;
     };
+    drive: ({ strapi }: {
+        strapi: import("@strapi/types/dist/core").Strapi;
+    }) => {
+        status: (ctx: {
+            request: {
+                body?: Record<string, unknown>;
+            };
+            query: Record<string, unknown>;
+            params?: Record<string, string>;
+            status: number;
+            body: unknown;
+        }) => Promise<void>;
+        saveClient: (ctx: {
+            request: {
+                body?: Record<string, unknown>;
+            };
+            query: Record<string, unknown>;
+            params?: Record<string, string>;
+            status: number;
+            body: unknown;
+        }) => Promise<void>;
+        removeClient: (ctx: {
+            request: {
+                body?: Record<string, unknown>;
+            };
+            query: Record<string, unknown>;
+            params?: Record<string, string>;
+            status: number;
+            body: unknown;
+        }) => Promise<void>;
+        authorizationUrl: (ctx: {
+            request: {
+                body?: Record<string, unknown>;
+            };
+            query: Record<string, unknown>;
+            params?: Record<string, string>;
+            status: number;
+            body: unknown;
+        }) => Promise<void>;
+        exchange: (ctx: {
+            request: {
+                body?: Record<string, unknown>;
+            };
+            query: Record<string, unknown>;
+            params?: Record<string, string>;
+            status: number;
+            body: unknown;
+        }) => Promise<void>;
+        disconnect: (ctx: {
+            request: {
+                body?: Record<string, unknown>;
+            };
+            query: Record<string, unknown>;
+            params?: Record<string, string>;
+            status: number;
+            body: unknown;
+        }) => Promise<void>;
+        links: (ctx: {
+            request: {
+                body?: Record<string, unknown>;
+            };
+            query: Record<string, unknown>;
+            params?: Record<string, string>;
+            status: number;
+            body: unknown;
+        }) => Promise<void>;
+        mark: (ctx: {
+            request: {
+                body?: Record<string, unknown>;
+            };
+            query: Record<string, unknown>;
+            params?: Record<string, string>;
+            status: number;
+            body: unknown;
+        }) => Promise<void>;
+        unmark: (ctx: {
+            request: {
+                body?: Record<string, unknown>;
+            };
+            query: Record<string, unknown>;
+            params?: Record<string, string>;
+            status: number;
+            body: unknown;
+        }) => Promise<void>;
+        syncNow: (ctx: {
+            request: {
+                body?: Record<string, unknown>;
+            };
+            query: Record<string, unknown>;
+            params?: Record<string, string>;
+            status: number;
+            body: unknown;
+        }) => Promise<void>;
+        browse: (ctx: {
+            request: {
+                body?: Record<string, unknown>;
+            };
+            query: Record<string, unknown>;
+            params?: Record<string, string>;
+            status: number;
+            body: unknown;
+        }) => Promise<void>;
+        count: (ctx: {
+            request: {
+                body?: Record<string, unknown>;
+            };
+            query: Record<string, unknown>;
+            params?: Record<string, string>;
+            status: number;
+            body: unknown;
+        }) => Promise<void>;
+        trash: (ctx: {
+            request: {
+                body?: Record<string, unknown>;
+            };
+            query: Record<string, unknown>;
+            params?: Record<string, string>;
+            status: number;
+            body: unknown;
+        }) => Promise<void>;
+        origin: (ctx: {
+            request: {
+                body?: Record<string, unknown>;
+            };
+            query: Record<string, unknown>;
+            params?: Record<string, string>;
+            status: number;
+            body: unknown;
+        }) => Promise<void>;
+    };
     articles: ({ strapi }: {
         strapi: import("@strapi/types/dist/core").Strapi;
     }) => {

package/dist/server/src/drive/client.d.ts

@@ -0,0 +1,32 @@
+import type { DriveClient } from './clientConfig';
+import type { Fetch } from './oauth';
+export interface DriveCredentials {
+    client: DriveClient;
+    refreshToken: string;
+}
+export interface DriveAbout {
+    email: string;
+    usage: number;
+    /** `null` si la cuenta no tiene tope de espacio. */
+    limit: number | null;
+}
+/** No hay cliente guardado o la cuenta no se ha conectado. */
+export declare class DriveNotConnectedError extends Error {
+    constructor();
+}
+export declare class DriveApiError extends Error {
+    readonly status: number;
+    constructor(status: number, message: string);
+}
+export declare const createDriveClient: ({ getCredentials, fetch: fetchFn, sleep, now, }: {
+    getCredentials: () => Promise<DriveCredentials | null>;
+    fetch: Fetch;
+    sleep?: (ms: number) => Promise<void>;
+    now?: () => number;
+}) => {
+    request: <T = unknown>(path: string, init?: RequestInit) => Promise<T>;
+    download: (path: string) => Promise<Uint8Array>;
+    about: () => Promise<DriveAbout>;
+    reset: () => any;
+};
+export type DriveHttpClient = ReturnType<typeof createDriveClient>;

package/dist/server/src/drive/clientConfig.d.ts

@@ -0,0 +1,27 @@
+/** Clave del cliente OAuth en el plugin store. */
+export declare const DRIVE_CLIENT_KEY = "DRIVE_CLIENT";
+export interface DriveClient {
+    clientId: string;
+    clientSecret: string;
+    redirectUris: string[];
+}
+export type ClientParseResult = {
+    ok: true;
+    client: DriveClient;
+} | {
+    ok: false;
+    message: string;
+};
+/** Estado público para `GET /drive/status`: el Client ID y los últimos 4 del secreto. */
+export interface PublicDriveClient {
+    configured: boolean;
+    clientId: string | null;
+    last4: string | null;
+}
+/** Valida el JSON de Google Cloud y que autorice `redirectUri`, la URL de Ajustes desde la que se carga. */
+export declare const parseClientConfig: (value: unknown, redirectUri: string) => ClientParseResult;
+/** JSON mínimo que se guarda en el store, con la misma forma que el de Google. */
+export declare const storedClient: (client: DriveClient) => string;
+/** Cliente guardado, o `null` si no hay o está dañado. */
+export declare const loadClient: (stored: unknown) => DriveClient | null;
+export declare const publicClient: (stored: unknown) => PublicDriveClient;

package/dist/server/src/drive/common.d.ts

@@ -0,0 +1,6 @@
+import type { CmsFile } from './model';
+export declare const MAX_FILE_BYTES: number;
+export declare const withoutEcho: <T>(work: () => Promise<T>) => Promise<T>;
+export declare const isEcho: () => boolean;
+/** Versión de un archivo: reemplazarlo en Strapi cambia su URL (diseño D4). */
+export declare const versionOf: (file: CmsFile) => string;

package/dist/server/src/drive/fakes.d.ts

@@ -0,0 +1,104 @@
+import type { DriveChange, UploadInput } from './files';
+import type { Cms, CmsWriter, DriveLink, DriveOp, LinkRepo, OpQueue } from './model';
+type FolderSeed = {
+    id: number;
+    name: string;
+    parentId: number | null;
+};
+type FileSeed = {
+    id: number;
+    name: string;
+    folderId: number | null;
+    url?: string;
+    size?: number;
+    mime?: string;
+};
+/** Biblioteca en memoria. `pathId` = `id` para simplificar; las rutas se calculan como en Strapi. */
+export declare const fakeCms: (folderSeeds: FolderSeed[], fileSeeds?: FileSeed[]) => {
+    cms: Cms;
+    writer: CmsWriter;
+    folders: Map<number, FolderSeed>;
+    files: Map<number, FileSeed>;
+    contents: Map<number, Uint8Array>;
+};
+export interface FakeDriveItem {
+    id: string;
+    name: string;
+    parent: string;
+    folder: boolean;
+    trashed: boolean;
+    content?: string;
+    description?: string;
+    mimeType?: string;
+    revisions: number;
+}
+/**
+ * Drive en memoria con las operaciones del puerto `DriveOps` y un registro de cambios como el de
+ * `changes.list`. `external` simula lo que alguien hace directo en Drive.
+ */
+export declare const fakeDrive: () => {
+    ops: {
+        findChild: (parentId: string, name: string) => Promise<import("./files").DriveFile>;
+        createFolder: (parentId: string, name: string) => Promise<string>;
+        uploadFile: (parentId: string, file: UploadInput) => Promise<import("./files").Uploaded>;
+        updateContent: (driveId: string, file: UploadInput) => Promise<import("./files").Uploaded>;
+        updateMeta: (driveId: string, change: {
+            name?: string;
+            from?: string;
+            to?: string;
+        }) => Promise<void>;
+        trash: (driveId: string) => Promise<void>;
+        download: (driveId: string) => Promise<Uint8Array>;
+        startPageToken: () => Promise<string>;
+        rootId: () => Promise<string>;
+        listChildren: (parentId: string, pageToken?: string) => Promise<{
+            items: import("./files").DriveEntry[];
+            nextPageToken: string;
+        }>;
+        getFile: (id: string) => Promise<import("./files").DriveEntry>;
+        getMeta: (id: string) => Promise<{
+            id: string;
+            name: string;
+            mimeType: string;
+            parents?: string[];
+            trashed?: boolean;
+            md5Checksum?: string;
+            size?: string;
+        }>;
+        countTree: (folderId: string) => Promise<{
+            files: number;
+            folders: number;
+            truncated: boolean;
+        }>;
+        listChanges: (pageToken: string) => Promise<{
+            changes?: DriveChange[];
+            nextPageToken?: string;
+            newStartPageToken?: string;
+        }>;
+    };
+    items: Map<string, FakeDriveItem>;
+    add: (parent: string, name: string, folder: boolean, extra?: Partial<FakeDriveItem>) => string;
+    external: {
+        /** Como `rename`, pero sin dejar rastro en `changes.list` (cambios previos al punto de partida). */
+        renameUnlogged: (id: string, name: string) => void;
+        trashUnlogged: (id: string) => void;
+        add: (parent: string, name: string, content: string, mimeType?: string) => string;
+        addFolder: (parent: string, name: string) => string;
+        edit: (id: string, content: string) => void;
+        rename: (id: string, name: string) => void;
+        move: (id: string, parent: string) => void;
+        trash: (id: string) => void;
+    };
+    log: DriveChange[];
+    pathOf: (id: string) => string;
+    live: () => string[];
+};
+export declare const memoryLinks: () => {
+    repo: LinkRepo;
+    rows: Map<number, DriveLink>;
+};
+export declare const memoryOps: () => {
+    queue: OpQueue;
+    rows: Map<number, DriveOp>;
+};
+export {};