@pitcher/cli-scripts 2.11.0 → 2.13.0

package/dist/src/commands/ld/cert.js

@@ -0,0 +1,355 @@
+import { Command } from 'commander';
+import { ldClientFor, ldData, toLdCliError, requireInstance, pickTruthy } from '../../core/ld.js';
+import { ok, fail } from '../../core/envelope.js';
+import { createCliError } from '../../core/errors.js';
+import { parseJsonInput } from '../../core/readInput.js';
+import { listLimitOffsetParams } from '../../core/pagination.js';
+import { assertIntFlags } from '../../schema/content.js';
+import { csv, ldFlags, render, boolFlag } from './course.js';
+const ADMIN = '/admin/certificates';
+// ---- run* functions ----
+export async function runLdCertTags(opts, deps = {}) {
+    try {
+        const instanceId = requireInstance(opts);
+        const client = await ldClientFor(opts, deps);
+        const res = await client.get(`${ADMIN}/tags`, { params: { instanceId } });
+        return ok(ldData(res));
+    }
+    catch (e) {
+        return fail(toLdCliError(e));
+    }
+}
+export async function runLdCertList(opts, deps = {}) {
+    try {
+        const instanceId = requireInstance(opts);
+        assertIntFlags(opts); // rejects --limit/--offset that parsed to NaN (matches sibling commands)
+        const params = { instanceId, ...listLimitOffsetParams(opts), ...pickTruthy(opts, ['status', 'title', 'tags']) };
+        const client = await ldClientFor(opts, deps);
+        const res = await client.get(ADMIN, { params });
+        return ok(ldData(res));
+    }
+    catch (e) {
+        return fail(toLdCliError(e));
+    }
+}
+export async function runLdCertGet(opts, deps = {}) {
+    try {
+        const instanceId = requireInstance(opts);
+        if (!opts.id)
+            throw createCliError('VALIDATION', '--id is required');
+        const client = await ldClientFor(opts, deps);
+        const res = await client.get(`${ADMIN}/${opts.id}`, { params: { instanceId } });
+        return ok(ldData(res));
+    }
+    catch (e) {
+        return fail(toLdCliError(e));
+    }
+}
+// createCertificateSchema requires instanceId + title IN THE BODY (validateBody parses req.body
+// alone; the controller also reads instanceId from the query, but validation runs first, so
+// instanceId must be in the body too). description/tags/validityPeriod pass through when set.
+export async function runLdCertCreate(opts, deps = {}) {
+    try {
+        const instanceId = requireInstance(opts);
+        if (!opts.title)
+            throw createCliError('VALIDATION', '--title is required');
+        const body = { instanceId, title: opts.title };
+        if (opts.description !== undefined)
+            body.description = opts.description;
+        if (opts.tags !== undefined)
+            body.tags = opts.tags;
+        if (opts.validityPeriod !== undefined)
+            body.validityPeriod = opts.validityPeriod;
+        const client = await ldClientFor(opts, deps);
+        const res = await client.post(ADMIN, body, { params: { instanceId } });
+        return ok(ldData(res));
+    }
+    catch (e) {
+        return fail(toLdCliError(e));
+    }
+}
+// updateCertificateSchema is createCertificateSchema.partial() — every field optional. Send only what changed.
+export async function runLdCertUpdate(opts, deps = {}) {
+    try {
+        const instanceId = requireInstance(opts);
+        if (!opts.id)
+            throw createCliError('VALIDATION', '--id is required');
+        const body = {};
+        if (opts.title !== undefined)
+            body.title = opts.title;
+        if (opts.description !== undefined)
+            body.description = opts.description;
+        if (opts.tags !== undefined)
+            body.tags = opts.tags;
+        if (opts.validityPeriod !== undefined)
+            body.validityPeriod = opts.validityPeriod;
+        const client = await ldClientFor(opts, deps);
+        const res = await client.put(`${ADMIN}/${opts.id}`, body, { params: { instanceId } });
+        return ok(ldData(res));
+    }
+    catch (e) {
+        return fail(toLdCliError(e));
+    }
+}
+export async function runLdCertDelete(opts, deps = {}) {
+    try {
+        const instanceId = requireInstance(opts);
+        if (!opts.id)
+            throw createCliError('VALIDATION', '--id is required');
+        const client = await ldClientFor(opts, deps);
+        const res = await client.delete(`${ADMIN}/${opts.id}`, { params: { instanceId } });
+        return ok(ldData(res) ?? { id: opts.id, deleted: true });
+    }
+    catch (e) {
+        return fail(toLdCliError(e));
+    }
+}
+export async function runLdCertTrainingMaterials(opts, deps = {}) {
+    try {
+        const instanceId = requireInstance(opts);
+        if (!opts.id)
+            throw createCliError('VALIDATION', '--id is required');
+        const client = await ldClientFor(opts, deps);
+        const res = await client.get(`${ADMIN}/${opts.id}/training-materials`, { params: { instanceId } });
+        return ok(ldData(res));
+    }
+    catch (e) {
+        return fail(toLdCliError(e));
+    }
+}
+// ---- modules ----
+export async function runLdCertListModules(opts, deps = {}) {
+    try {
+        const instanceId = requireInstance(opts);
+        if (!opts.id)
+            throw createCliError('VALIDATION', '--id is required');
+        const client = await ldClientFor(opts, deps);
+        const res = await client.get(`${ADMIN}/${opts.id}/modules`, { params: { instanceId } });
+        return ok(ldData(res));
+    }
+    catch (e) {
+        return fail(toLdCliError(e));
+    }
+}
+export async function runLdCertAddModules(opts, deps = {}) {
+    try {
+        const instanceId = requireInstance(opts);
+        if (!opts.id)
+            throw createCliError('VALIDATION', '--id is required');
+        if (!opts.moduleIds?.length)
+            throw createCliError('VALIDATION', '--module-ids is required (comma-separated)');
+        const client = await ldClientFor(opts, deps);
+        const res = await client.post(`${ADMIN}/${opts.id}/modules`, { moduleIds: opts.moduleIds }, { params: { instanceId } });
+        return ok(ldData(res));
+    }
+    catch (e) {
+        return fail(toLdCliError(e));
+    }
+}
+export async function runLdCertReorderModules(opts, deps = {}) {
+    try {
+        const instanceId = requireInstance(opts);
+        if (!opts.id)
+            throw createCliError('VALIDATION', '--id is required');
+        if (!opts.itemId)
+            throw createCliError('VALIDATION', '--item-id is required');
+        if (opts.newOrder === undefined || !Number.isInteger(opts.newOrder))
+            throw createCliError('VALIDATION', '--new-order is required (integer)');
+        const client = await ldClientFor(opts, deps);
+        const res = await client.put(`${ADMIN}/${opts.id}/modules/order`, { itemId: opts.itemId, newOrder: opts.newOrder, type: 'module' }, { params: { instanceId } });
+        return ok(ldData(res));
+    }
+    catch (e) {
+        return fail(toLdCliError(e));
+    }
+}
+export async function runLdCertUpdateModule(opts, deps = {}) {
+    try {
+        const instanceId = requireInstance(opts);
+        if (!opts.id || !opts.moduleId)
+            throw createCliError('VALIDATION', '--id and --module-id are required');
+        const body = {};
+        if (opts.isRequired !== undefined)
+            body.isRequired = opts.isRequired;
+        const client = await ldClientFor(opts, deps);
+        const res = await client.put(`${ADMIN}/${opts.id}/modules/${opts.moduleId}`, body, { params: { instanceId } });
+        return ok(ldData(res));
+    }
+    catch (e) {
+        return fail(toLdCliError(e));
+    }
+}
+export async function runLdCertRemoveModule(opts, deps = {}) {
+    try {
+        const instanceId = requireInstance(opts);
+        if (!opts.id || !opts.moduleId)
+            throw createCliError('VALIDATION', '--id and --module-id are required');
+        const client = await ldClientFor(opts, deps);
+        const res = await client.delete(`${ADMIN}/${opts.id}/modules/${opts.moduleId}`, { params: { instanceId } });
+        return ok(ldData(res) ?? { removed: true });
+    }
+    catch (e) {
+        return fail(toLdCliError(e));
+    }
+}
+// ---- courses ----
+export async function runLdCertListCourses(opts, deps = {}) {
+    try {
+        const instanceId = requireInstance(opts);
+        if (!opts.id)
+            throw createCliError('VALIDATION', '--id is required');
+        const client = await ldClientFor(opts, deps);
+        const res = await client.get(`${ADMIN}/${opts.id}/courses`, { params: { instanceId } });
+        return ok(ldData(res));
+    }
+    catch (e) {
+        return fail(toLdCliError(e));
+    }
+}
+// NOTE: cert course-add uses `courseIds` (UNLIKE the module add, which uses `moduleIds`).
+export async function runLdCertAddCourses(opts, deps = {}) {
+    try {
+        const instanceId = requireInstance(opts);
+        if (!opts.id)
+            throw createCliError('VALIDATION', '--id is required');
+        if (!opts.courseIds?.length)
+            throw createCliError('VALIDATION', '--course-ids is required (comma-separated)');
+        const client = await ldClientFor(opts, deps);
+        const res = await client.post(`${ADMIN}/${opts.id}/courses`, { courseIds: opts.courseIds }, { params: { instanceId } });
+        return ok(ldData(res));
+    }
+    catch (e) {
+        return fail(toLdCliError(e));
+    }
+}
+export async function runLdCertReorderCourses(opts, deps = {}) {
+    try {
+        const instanceId = requireInstance(opts);
+        if (!opts.id)
+            throw createCliError('VALIDATION', '--id is required');
+        if (!opts.itemId)
+            throw createCliError('VALIDATION', '--item-id is required');
+        if (opts.newOrder === undefined || !Number.isInteger(opts.newOrder))
+            throw createCliError('VALIDATION', '--new-order is required (integer)');
+        const client = await ldClientFor(opts, deps);
+        const res = await client.put(`${ADMIN}/${opts.id}/courses/order`, { itemId: opts.itemId, newOrder: opts.newOrder, type: 'course' }, { params: { instanceId } });
+        return ok(ldData(res));
+    }
+    catch (e) {
+        return fail(toLdCliError(e));
+    }
+}
+export async function runLdCertUpdateCourse(opts, deps = {}) {
+    try {
+        const instanceId = requireInstance(opts);
+        if (!opts.id || !opts.courseId)
+            throw createCliError('VALIDATION', '--id and --course-id are required');
+        const body = {};
+        if (opts.isRequired !== undefined)
+            body.isRequired = opts.isRequired;
+        const client = await ldClientFor(opts, deps);
+        const res = await client.put(`${ADMIN}/${opts.id}/courses/${opts.courseId}`, body, { params: { instanceId } });
+        return ok(ldData(res));
+    }
+    catch (e) {
+        return fail(toLdCliError(e));
+    }
+}
+export async function runLdCertRemoveCourse(opts, deps = {}) {
+    try {
+        const instanceId = requireInstance(opts);
+        if (!opts.id || !opts.courseId)
+            throw createCliError('VALIDATION', '--id and --course-id are required');
+        const client = await ldClientFor(opts, deps);
+        const res = await client.delete(`${ADMIN}/${opts.id}/courses/${opts.courseId}`, { params: { instanceId } });
+        return ok(ldData(res) ?? { removed: true });
+    }
+    catch (e) {
+        return fail(toLdCliError(e));
+    }
+}
+// ---- assessments ----
+export async function runLdCertListAssessments(opts, deps = {}) {
+    try {
+        const instanceId = requireInstance(opts);
+        if (!opts.id)
+            throw createCliError('VALIDATION', '--id is required');
+        const client = await ldClientFor(opts, deps);
+        const res = await client.get(`${ADMIN}/${opts.id}/assessments`, { params: { instanceId } });
+        return ok(ldData(res));
+    }
+    catch (e) {
+        return fail(toLdCliError(e));
+    }
+}
+// The cert assessments payload is a full array [{ id, isRequired? }], not just ids — accepted as
+// inline JSON (--assessments) or a file (--assessments-file), resolved by resolveTextInput then parsed.
+export async function runLdCertAddAssessments(opts, deps = {}) {
+    try {
+        const instanceId = requireInstance(opts);
+        if (!opts.id)
+            throw createCliError('VALIDATION', '--id is required');
+        const assessments = parseJsonInput(opts.assessments, opts.assessmentsFile, 'assessments');
+        const client = await ldClientFor(opts, deps);
+        const res = await client.post(`${ADMIN}/${opts.id}/assessments`, { assessments }, { params: { instanceId } });
+        return ok(ldData(res));
+    }
+    catch (e) {
+        return fail(toLdCliError(e));
+    }
+}
+export async function runLdCertUpdateAssessment(opts, deps = {}) {
+    try {
+        const instanceId = requireInstance(opts);
+        if (!opts.id || !opts.assessmentId)
+            throw createCliError('VALIDATION', '--id and --assessment-id are required');
+        // updateCertAssessmentSchema requires isRequired — sending {} 400s. Guard client-side.
+        if (opts.isRequired === undefined)
+            throw createCliError('VALIDATION', '--is-required is required (true|false)');
+        const client = await ldClientFor(opts, deps);
+        const res = await client.patch(`${ADMIN}/${opts.id}/assessments/${opts.assessmentId}`, { isRequired: opts.isRequired }, { params: { instanceId } });
+        return ok(ldData(res));
+    }
+    catch (e) {
+        return fail(toLdCliError(e));
+    }
+}
+export async function runLdCertRemoveAssessment(opts, deps = {}) {
+    try {
+        const instanceId = requireInstance(opts);
+        if (!opts.id || !opts.assessmentId)
+            throw createCliError('VALIDATION', '--id and --assessment-id are required');
+        const client = await ldClientFor(opts, deps);
+        const res = await client.delete(`${ADMIN}/${opts.id}/assessments/${opts.assessmentId}`, { params: { instanceId } });
+        return ok(ldData(res) ?? { removed: true });
+    }
+    catch (e) {
+        return fail(toLdCliError(e));
+    }
+}
+// ---- commander subcommand ----
+export function createCertSubcommand() {
+    const cmd = new Command('cert').description('Author L&D certificates');
+    ldFlags(cmd.command('tags')).action(render(runLdCertTags));
+    ldFlags(cmd.command('list')).option('--status <s>').option('--title <t>').option('--tags <t>', 'Comma-separated', csv).option('--limit <n>', '', Number).option('--offset <n>', '', Number).action(render(runLdCertList));
+    ldFlags(cmd.command('get')).option('--id <id>', 'Certificate ID (required)').action(render(runLdCertGet));
+    ldFlags(cmd.command('create')).option('--title <t>', 'required').option('--description <d>').option('--tags <t>', 'Comma-separated', csv).option('--validity-period <n>', 'days, integer', Number).action(render(runLdCertCreate));
+    ldFlags(cmd.command('update')).option('--id <id>', 'required').option('--title <t>').option('--description <d>').option('--tags <t>', 'Comma-separated', csv).option('--validity-period <n>', '', Number).action(render(runLdCertUpdate));
+    ldFlags(cmd.command('delete')).option('--id <id>', 'required').action(render(runLdCertDelete));
+    ldFlags(cmd.command('training-materials')).option('--id <id>', 'required').action(render(runLdCertTrainingMaterials));
+    ldFlags(cmd.command('list-modules')).option('--id <id>', 'required').action(render(runLdCertListModules));
+    ldFlags(cmd.command('add-modules')).option('--id <id>', 'required').option('--module-ids <ids>', 'Comma-separated (required)', csv).action(render(runLdCertAddModules));
+    ldFlags(cmd.command('reorder-modules')).option('--id <id>', 'required').option('--item-id <id>', 'required').option('--new-order <n>', 'integer (required)', Number).action(render(runLdCertReorderModules));
+    ldFlags(cmd.command('update-module')).option('--id <id>', 'required').option('--module-id <id>', 'required').option('--is-required <bool>', 'true|false', boolFlag).action(render(runLdCertUpdateModule));
+    ldFlags(cmd.command('remove-module')).option('--id <id>', 'required').option('--module-id <id>', 'required').action(render(runLdCertRemoveModule));
+    ldFlags(cmd.command('list-courses')).option('--id <id>', 'required').action(render(runLdCertListCourses));
+    ldFlags(cmd.command('add-courses')).option('--id <id>', 'required').option('--course-ids <ids>', 'Comma-separated (required)', csv).action(render(runLdCertAddCourses));
+    ldFlags(cmd.command('reorder-courses')).option('--id <id>', 'required').option('--item-id <id>', 'required').option('--new-order <n>', 'integer (required)', Number).action(render(runLdCertReorderCourses));
+    ldFlags(cmd.command('update-course')).option('--id <id>', 'required').option('--course-id <id>', 'required').option('--is-required <bool>', 'true|false', boolFlag).action(render(runLdCertUpdateCourse));
+    ldFlags(cmd.command('remove-course')).option('--id <id>', 'required').option('--course-id <id>', 'required').action(render(runLdCertRemoveCourse));
+    ldFlags(cmd.command('list-assessments')).option('--id <id>', 'required').action(render(runLdCertListAssessments));
+    ldFlags(cmd.command('add-assessments')).option('--id <id>', 'required').option('--assessments <json>', 'Inline assessments JSON array').option('--assessments-file <path>').action(render(runLdCertAddAssessments));
+    ldFlags(cmd.command('update-assessment')).option('--id <id>', 'required').option('--assessment-id <id>', 'required').option('--is-required <bool>', 'true|false (required)', boolFlag).action(render(runLdCertUpdateAssessment));
+    ldFlags(cmd.command('remove-assessment')).option('--id <id>', 'required').option('--assessment-id <id>', 'required').action(render(runLdCertRemoveAssessment));
+    return cmd;
+}

package/dist/src/commands/ld/course.d.ts

@@ -0,0 +1,62 @@
+import { Command } from 'commander';
+import { type LdCommonOpts, type LdDeps } from '../../core/ld.js';
+import { type Envelope } from '../../core/envelope.js';
+export declare function runLdCourseList(opts: LdCommonOpts & {
+    status?: string;
+    title?: string;
+    tags?: string[];
+    limit?: number;
+    offset?: number;
+}, deps?: LdDeps): Promise<Envelope<unknown>>;
+export declare function runLdCourseGet(opts: LdCommonOpts & {
+    id?: string;
+}, deps?: LdDeps): Promise<Envelope<unknown>>;
+export declare function runLdCourseTags(opts: LdCommonOpts, deps?: LdDeps): Promise<Envelope<unknown>>;
+export declare function runLdCourseCreate(opts: LdCommonOpts & Record<string, unknown>, deps?: LdDeps): Promise<Envelope<unknown>>;
+export declare function runLdCourseUpdate(opts: LdCommonOpts & {
+    id?: string;
+} & Record<string, unknown>, deps?: LdDeps): Promise<Envelope<unknown>>;
+export declare function runLdCourseDelete(opts: LdCommonOpts & {
+    id?: string;
+}, deps?: LdDeps): Promise<Envelope<unknown>>;
+export declare const runLdCoursePublish: (o: LdCommonOpts & {
+    id?: string;
+}, d?: LdDeps) => Promise<Envelope<unknown>>;
+export declare const runLdCourseUnpublish: (o: LdCommonOpts & {
+    id?: string;
+}, d?: LdDeps) => Promise<Envelope<unknown>>;
+export declare function runLdCourseGetCanvas(opts: LdCommonOpts & {
+    id?: string;
+}, deps?: LdDeps): Promise<Envelope<unknown>>;
+export declare function runLdCourseSetCanvas(opts: LdCommonOpts & {
+    id?: string;
+    canvas?: string;
+    canvasFile?: string;
+}, deps?: LdDeps): Promise<Envelope<unknown>>;
+export declare function runLdCourseListModules(opts: LdCommonOpts & {
+    id?: string;
+}, deps?: LdDeps): Promise<Envelope<unknown>>;
+export declare function runLdCourseAddToModules(opts: LdCommonOpts & {
+    id?: string;
+    moduleIds?: string[];
+}, deps?: LdDeps): Promise<Envelope<unknown>>;
+export declare function runLdCourseRemoveFromModule(opts: LdCommonOpts & {
+    id?: string;
+    moduleId?: string;
+}, deps?: LdDeps): Promise<Envelope<unknown>>;
+export declare function runLdCourseListAssessments(opts: LdCommonOpts & {
+    id?: string;
+}, deps?: LdDeps): Promise<Envelope<unknown>>;
+export declare function runLdCourseLinkAssessments(opts: LdCommonOpts & {
+    id?: string;
+    assessmentIds?: string[];
+}, deps?: LdDeps): Promise<Envelope<unknown>>;
+export declare function runLdCourseUnlinkAssessment(opts: LdCommonOpts & {
+    id?: string;
+    assessmentId?: string;
+}, deps?: LdDeps): Promise<Envelope<unknown>>;
+export declare const csv: (v: string) => string[];
+export declare const boolFlag: (v: string) => boolean;
+export declare const ldFlags: (c: Command) => Command;
+export declare const render: (fn: (o: Record<string, unknown>, d?: LdDeps) => Promise<Envelope<unknown>>) => (o: Record<string, unknown>, c: Command) => Promise<void>;
+export declare function createCourseSubcommand(): Command;