@nickchristensen/ppls 1.0.5 → 1.2.0

package/dist/commands/documents/list.js

@@ -1,14 +1,178 @@
+import { Flags } from '@oclif/core';
+import { dateLike } from '../../flags/date-like.js';
+import { isDateOnly } from '../../helpers/date-utils.js';
 import { ListCommand } from '../../list-command.js';
+const DATE_RANGE_FLAGS = {
+    added: {
+        after: 'added-after',
+        before: 'added-before',
+    },
+    created: {
+        after: 'created-after',
+        before: 'created-before',
+    },
+    modified: {
+        after: 'modified-after',
+        before: 'modified-before',
+    },
+};
+const addDateRangeParams = (params, field, flags) => {
+    const { after, before } = DATE_RANGE_FLAGS[field];
+    const typedFlags = flags;
+    const afterValue = typedFlags[after];
+    const beforeValue = typedFlags[before];
+    if (afterValue) {
+        const key = isDateOnly(afterValue) ? `${field}__date__gte` : `${field}__gte`;
+        params[key] = afterValue;
+    }
+    if (beforeValue) {
+        const key = isDateOnly(beforeValue) ? `${field}__date__lte` : `${field}__lte`;
+        params[key] = beforeValue;
+    }
+};
 export default class DocumentsList extends ListCommand {
     static description = 'List documents';
     static examples = ['<%= config.bin %> <%= command.id %>'];
+    static flags = {
+        ...ListCommand.baseFlags,
+        'added-after': dateLike({
+            description: 'Filter by added date (YYYY-MM-DD) or datetime (ISO 8601) >= value',
+            exclusive: ['id-in'],
+            helpGroup: 'FILTER',
+        }),
+        'added-before': dateLike({
+            description: 'Filter by added date (YYYY-MM-DD) or datetime (ISO 8601) <= value',
+            exclusive: ['id-in'],
+            helpGroup: 'FILTER',
+        }),
+        correspondent: Flags.integer({
+            delimiter: ',',
+            description: 'Filter by correspondent ids (repeatable or comma-separated)',
+            exclusive: ['id-in'],
+            helpGroup: 'FILTER',
+            multiple: true,
+        }),
+        'correspondent-not': Flags.integer({
+            delimiter: ',',
+            description: 'Exclude correspondent ids (repeatable or comma-separated)',
+            exclusive: ['id-in'],
+            helpGroup: 'FILTER',
+            multiple: true,
+        }),
+        'created-after': dateLike({
+            description: 'Filter by created date (YYYY-MM-DD) or datetime (ISO 8601) >= value',
+            exclusive: ['id-in'],
+            helpGroup: 'FILTER',
+        }),
+        'created-before': dateLike({
+            description: 'Filter by created date (YYYY-MM-DD) or datetime (ISO 8601) <= value',
+            exclusive: ['id-in'],
+            helpGroup: 'FILTER',
+        }),
+        'document-type': Flags.integer({
+            delimiter: ',',
+            description: 'Filter by document type ids (repeatable or comma-separated)',
+            exclusive: ['id-in'],
+            helpGroup: 'FILTER',
+            multiple: true,
+        }),
+        'document-type-not': Flags.integer({
+            delimiter: ',',
+            description: 'Exclude document type ids (repeatable or comma-separated)',
+            exclusive: ['id-in'],
+            helpGroup: 'FILTER',
+            multiple: true,
+        }),
+        'modified-after': dateLike({
+            description: 'Filter by modified date (YYYY-MM-DD) or datetime (ISO 8601) >= value',
+            exclusive: ['id-in'],
+            helpGroup: 'FILTER',
+        }),
+        'modified-before': dateLike({
+            description: 'Filter by modified date (YYYY-MM-DD) or datetime (ISO 8601) <= value',
+            exclusive: ['id-in'],
+            helpGroup: 'FILTER',
+        }),
+        'no-correspondent': Flags.boolean({
+            description: 'Filter documents with no correspondent',
+            exclusive: ['correspondent', 'correspondent-not', 'id-in'],
+            helpGroup: 'FILTER',
+        }),
+        'no-document-type': Flags.boolean({
+            description: 'Filter documents with no document type',
+            exclusive: ['document-type', 'document-type-not', 'id-in'],
+            helpGroup: 'FILTER',
+        }),
+        'no-tag': Flags.boolean({
+            description: 'Filter documents with no tags',
+            exclusive: ['tag', 'tag-all', 'tag-not', 'id-in'],
+            helpGroup: 'FILTER',
+        }),
+        tag: Flags.integer({
+            delimiter: ',',
+            description: 'Filter by tag ids (repeatable or comma-separated, OR)',
+            exclusive: ['id-in'],
+            helpGroup: 'FILTER',
+            multiple: true,
+        }),
+        'tag-all': Flags.integer({
+            delimiter: ',',
+            description: 'Filter by tag ids (repeatable or comma-separated, AND)',
+            exclusive: ['id-in'],
+            helpGroup: 'FILTER',
+            multiple: true,
+        }),
+        'tag-not': Flags.integer({
+            delimiter: ',',
+            description: 'Exclude tag ids (repeatable or comma-separated)',
+            exclusive: ['id-in'],
+            helpGroup: 'FILTER',
+            multiple: true,
+        }),
+    };
     listPath = '/api/documents/';
     tableAttrs = ['id', 'title', 'created', 'added', 'correspondent', 'document_type', 'tags'];
+    extraListFlags(flags) {
+        const typedFlags = flags;
+        return {
+            'added-after': typedFlags['added-after'],
+            'added-before': typedFlags['added-before'],
+            correspondent: typedFlags.correspondent,
+            'correspondent-not': typedFlags['correspondent-not'],
+            'created-after': typedFlags['created-after'],
+            'created-before': typedFlags['created-before'],
+            'document-type': typedFlags['document-type'],
+            'document-type-not': typedFlags['document-type-not'],
+            'modified-after': typedFlags['modified-after'],
+            'modified-before': typedFlags['modified-before'],
+            'no-correspondent': typedFlags['no-correspondent'],
+            'no-document-type': typedFlags['no-document-type'],
+            'no-tag': typedFlags['no-tag'],
+            tag: typedFlags.tag,
+            'tag-all': typedFlags['tag-all'],
+            'tag-not': typedFlags['tag-not'],
+        };
+    }
     listParams(flags) {
+        const typedFlags = flags;
         const params = super.listParams(flags);
         delete params.name__icontains;
-        // eslint-disable-next-line camelcase -- API uses double-underscore field names.
+        /* eslint-disable camelcase -- API uses double-underscore field names. */
         params.title__icontains = flags['name-contains'];
+        params.tags__id__in = typedFlags.tag;
+        params.tags__id__all = typedFlags['tag-all'];
+        params.tags__id__none = typedFlags['tag-not'];
+        params.is_tagged = typedFlags['no-tag'] ? 'false' : undefined;
+        params.correspondent__id__in = typedFlags.correspondent;
+        params.correspondent__id__none = typedFlags['correspondent-not'];
+        params.correspondent__isnull = typedFlags['no-correspondent'] ? 'true' : undefined;
+        params.document_type__id__in = typedFlags['document-type'];
+        params.document_type__id__none = typedFlags['document-type-not'];
+        params.document_type__isnull = typedFlags['no-document-type'] ? 'true' : undefined;
+        /* eslint-enable camelcase */
+        addDateRangeParams(params, 'added', typedFlags);
+        addDateRangeParams(params, 'created', typedFlags);
+        addDateRangeParams(params, 'modified', typedFlags);
         return params;
     }
     plainTemplate(document) {

package/dist/flags/date-like.d.ts

@@ -0,0 +1,4 @@
+export declare const dateLike: import("@oclif/core/interfaces").FlagDefinition<string, import("@oclif/core/interfaces").CustomOptions, {
+    multiple: false;
+    requiredOrDefaulted: false;
+}>;

package/dist/flags/date-like.js

@@ -0,0 +1,11 @@
+import { Flags } from '@oclif/core';
+import { isDateOnly, isDateTime } from '../helpers/date-utils.js';
+export const dateLike = Flags.custom({
+    helpValue: 'YYYY-MM-DD|ISO-8601',
+    async parse(input) {
+        if (isDateOnly(input) || isDateTime(input)) {
+            return input;
+        }
+        throw new Error('Use YYYY-MM-DD or an ISO 8601 datetime.');
+    },
+});

package/dist/list-command.d.ts

@@ -1,11 +1,11 @@
 import type { ApiFlags } from './base-command.js';
+import { BaseCommand } from './base-command.js';
 import { type TableColumn, type TableRow } from './helpers/table.js';
-import { PaginatedCommand } from './paginated-command.js';
 type ListCommandFlags = ApiFlags & {
-    'id-in'?: string;
+    'id-in'?: string[];
     'name-contains'?: string;
     page?: number;
-    'page-size'?: number;
+    'page-size': number;
     sort?: string;
 };
 type ListOutputFlags = ListCommandFlags & {
@@ -14,13 +14,13 @@ type ListOutputFlags = ListCommandFlags & {
     table?: boolean;
 };
 type TableColumnInput = string | TableColumn;
-export declare abstract class ListCommand<TRaw extends TableRow = TableRow, TOutput extends TableRow = TRaw> extends PaginatedCommand {
+export declare abstract class ListCommand<TRaw extends TableRow = TableRow, TOutput extends TableRow = TRaw> extends BaseCommand {
     static baseFlags: {
-        'id-in': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        'id-in': import("@oclif/core/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/interfaces").CustomOptions>;
         'name-contains': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
-        sort: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         page: import("@oclif/core/interfaces").OptionFlag<number | undefined, import("@oclif/core/interfaces").CustomOptions>;
-        'page-size': import("@oclif/core/interfaces").OptionFlag<number | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        'page-size': import("@oclif/core/interfaces").OptionFlag<number, import("@oclif/core/interfaces").CustomOptions>;
+        sort: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         'date-format': import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
         header: import("@oclif/core/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/interfaces").CustomOptions>;
         hostname: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
@@ -30,20 +30,21 @@ export declare abstract class ListCommand<TRaw extends TableRow = TableRow, TOut
     };
     protected abstract listPath: string;
     protected abstract tableAttrs: TableColumnInput[];
+    protected extraListFlags(_flags: Record<string, unknown>): Record<string, unknown>;
     protected fetchListResults<T>(options: {
         flags: ListCommandFlags;
-        params?: Record<string, number | string | undefined>;
+        params?: Record<string, number | number[] | string | string[] | undefined>;
         path: string;
     }): Promise<T[]>;
-    protected listParams(flags: ListCommandFlags): Record<string, number | string | undefined>;
+    protected listParams(flags: ListCommandFlags): Record<string, number | number[] | string | string[] | undefined>;
     protected abstract plainTemplate(item: TOutput): null | string | undefined;
     protected renderListOutput(options: {
         flags: ListOutputFlags;
         results: TOutput[];
     }): void;
     run(): Promise<TOutput[]>;
-    protected shouldAutoPaginate(flags: ListCommandFlags): boolean;
     protected transformResult(result: TRaw): TOutput;
     protected transformResults(results: TRaw[]): TOutput[];
+    private buildListUrl;
 }
 export {};

package/dist/list-command.js

@@ -1,22 +1,40 @@
 import { Flags } from '@oclif/core';
+import { BaseCommand } from './base-command.js';
 import { createValueFormatter } from './helpers/table.js';
-import { PaginatedCommand } from './paginated-command.js';
-export class ListCommand extends PaginatedCommand {
+export class ListCommand extends BaseCommand {
     static baseFlags = {
-        ...PaginatedCommand.baseFlags,
+        ...BaseCommand.baseFlags,
         'id-in': Flags.string({
-            description: 'Filter by id list (comma-separated)',
+            delimiter: ',',
+            description: 'Filter by id list (repeatable or comma-separated)',
             exclusive: ['name-contains'],
+            helpGroup: 'FILTER',
+            multiple: true,
         }),
         'name-contains': Flags.string({
             description: 'Filter by name substring',
             exclusive: ['id-in'],
+            helpGroup: 'FILTER',
+        }),
+        page: Flags.integer({
+            dependsOn: ['page-size'],
+            description: 'Page number to fetch',
+            min: 1,
+        }),
+        'page-size': Flags.integer({
+            default: async ({ flags }) => (flags.page === undefined ? Number.MAX_SAFE_INTEGER : undefined),
+            defaultHelp: async () => 'disable pagination, all results',
+            description: 'Number of results per page',
+            min: 1,
         }),
         sort: Flags.string({ description: 'Sort results by the provided field' }),
     };
+    extraListFlags(_flags) {
+        return {};
+    }
     async fetchListResults(options) {
         const { flags, params = {}, path } = options;
-        const url = this.buildPaginatedUrlFromFlags({
+        const url = this.buildListUrl({
             flags,
             params: {
                 ordering: flags.sort,
@@ -24,11 +42,14 @@ export class ListCommand extends PaginatedCommand {
             },
             path,
         });
-        return this.fetchPaginatedResultsFromFlags({
-            autoPaginate: this.shouldAutoPaginate(flags),
-            flags,
-            url,
-        });
+        const spinner = this.startSpinner(`Fetching ${url.pathname}`);
+        try {
+            const payload = await this.fetchJson(url, flags.token, flags.headers);
+            return payload.results ?? [];
+        }
+        finally {
+            spinner?.stop();
+        }
     }
     listParams(flags) {
         return {
@@ -67,6 +88,7 @@ export class ListCommand extends PaginatedCommand {
             'page-size': flags['page-size'],
             sort: flags.sort,
             token: apiFlags.token,
+            ...this.extraListFlags(flags),
         };
         const outputFlags = {
             ...listFlags,
@@ -86,13 +108,20 @@ export class ListCommand extends PaginatedCommand {
         });
         return results;
     }
-    shouldAutoPaginate(flags) {
-        return flags.page === undefined && flags['page-size'] === undefined;
-    }
     transformResult(result) {
         return result;
     }
     transformResults(results) {
         return results.map((result) => this.transformResult(result));
     }
+    buildListUrl(options) {
+        const { flags, params = {}, path } = options;
+        const { page } = flags;
+        const pageSize = flags['page-size'];
+        return this.buildApiUrl(flags.hostname, path, {
+            ...params,
+            page,
+            'page_size': pageSize,
+        });
+    }
 }