@aglyn/plugins-forms 1.0.0-beta.221 → 1.0.0-beta.223

package/src/lib/transfer/form-submissions-transfer.d.ts

@@ -0,0 +1,98 @@
+/**
+ * @license
+ * Copyright 2026 Aglyn LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { type FormFieldDecl, type FormFieldType } from '@aglyn/aglyn/app-utils/forms';
+import { type TransferCatalogInput, type TransferField, type TransferFieldGroup, type TransferFieldType } from '@aglyn/aglyn/data-transfer';
+import type { TransferRecordsHooks } from '@aglyn/aglyn/plugin-manager/plugin-transfer-resources';
+/** The prefix of an answer's field id; the rest is the form field's `fieldName`. */
+export declare const FORM_SUBMISSION_ANSWER_PREFIX = "answer:";
+/** How many of the most recent submissions the catalog reads for answers today's forms no longer ask. */
+export declare const FORM_SUBMISSIONS_ANSWER_SAMPLE_ROWS = 200;
+/**
+ * The most "other answers" columns the catalog offers. A submission's keys
+ * come from the visitor's request (up to twenty, each at most 64 characters),
+ * so a sample can hold keys no form ever asked; the most frequent are kept.
+ */
+export declare const FORM_SUBMISSIONS_OTHER_ANSWERS_MAX = 50;
+/** The group the submission's own details are listed under. */
+export declare const FORM_SUBMISSION_DETAILS_GROUP: TransferFieldGroup;
+/** The group of answers no form declares today. */
+export declare const FORM_SUBMISSION_OTHER_ANSWERS_GROUP: TransferFieldGroup;
+/** A form's questions are listed under `form:<formId>`. */
+export declare function formAnswersGroupId(formId: string): string;
+/** The field id an answer to `fieldName` is exported under. */
+export declare function formSubmissionAnswerFieldId(fieldName: string): string;
+/** What an answer is, from the form field that asked it. */
+export declare function formAnswerTransferType(fieldType: FormFieldType | undefined): TransferFieldType;
+/** The list filter, in this resource's terms: one form, and read or unread. */
+export interface FormSubmissionsFilter {
+    formId?: string;
+    read?: boolean;
+}
+/**
+ * The filter a dialog or a route handed over, or why it cannot be used.
+ * Refused rather than ignored: a filter dropped without a word exports more
+ * than the person asked for.
+ */
+export declare function readFormSubmissionsFilter(value: unknown): FormSubmissionsFilter;
+/** The submission's own details, in the order a person reads them. */
+export declare function formSubmissionDetailFields(): TransferField[];
+/** One form as the catalog reads it: its id, its name, and the questions it declares. */
+export interface FormQuestions {
+    id: string;
+    name: string;
+    fields: readonly FormFieldDecl[];
+}
+/**
+ * The catalog, from the forms read and the answer keys sampled (see the
+ * block header). `scoped` is true when the dialog was opened on one form.
+ */
+export declare function formSubmissionsCatalog(input: {
+    forms: readonly FormQuestions[];
+    sampledKeys: readonly string[];
+    scoped: boolean;
+}): TransferCatalogInput;
+/** The answer keys the sampled submissions carry, most frequent first, then first seen. */
+export declare function sampledAnswerKeys(rows: ReadonlyArray<Readonly<Record<string, unknown>> | undefined>): string[];
+/** Form id → the names of its rating questions, whose answers are numbers. */
+export type FormRatingQuestions = ReadonlyMap<string, ReadonlySet<string>>;
+/** The rating questions of each form (AGL-3548). */
+export declare function formRatingQuestions(forms: readonly FormQuestions[]): Map<string, Set<string>>;
+/**
+ * One submission as an export row: only `fieldIds`, keyed by field id. An
+ * answer is the value as the visitor sent it — but an answer to a rating
+ * question of the submission's form (`ratings`) that reads as a number is
+ * that number, so a JSON file holds `4` and a CSV writes it as one, not as
+ * text. A question they did not answer, or a field id this resource does
+ * not know, is `null`.
+ */
+export declare function formSubmissionTransferRow(id: string, data: Readonly<Record<string, unknown>>, fieldIds: readonly string[], ratings?: FormRatingQuestions): Record<string, unknown>;
+/**
+ * Where the next page of a query starts: the last row's `createdAt` (seconds
+ * and nanoseconds, so two submissions a microsecond apart stay apart) and
+ * its id. A selection's cursor is the offset into the ids.
+ */
+export declare function formSubmissionsCursor(createdAt: unknown, id: string): string;
+export interface FormSubmissionsTransferDeps {
+    firestore: FirebaseFirestore.Firestore;
+}
+/** The hooks an export-only records resource answers with: no apply or revert. */
+export type FormSubmissionsTransferResource = Required<Pick<TransferRecordsHooks, 'matchKeys' | 'fields' | 'count' | 'readPage' | 'lookup'>>;
+/**
+ * The form submissions resource's server half (see the block header).
+ * Firestore is handed in, so a spec runs it over an in-memory one.
+ */
+export declare function createFormSubmissionsTransferResource(deps: FormSubmissionsTransferDeps): FormSubmissionsTransferResource;

package/src/lib/transfer/form-submissions-transfer.js

@@ -0,0 +1,563 @@
+import { _ as _extends } from "@swc/helpers/_/_extends";
+/**
+ * @license
+ * Copyright 2026 Aglyn LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */ import { FORMS_MAX_PER_HOST } from "@aglyn/aglyn/app-utils/forms";
+import { TRANSFER_ID_FIELD, buildMatchLookup, transferIdField } from "@aglyn/aglyn/data-transfer";
+import { FieldPath, Timestamp } from "firebase-admin/firestore";
+import { FORM_SUBMISSIONS_MATCH_KEYS } from "./form-submissions-transfer-key.js";
+/*==========================================
+ * A SITE'S FORM SUBMISSIONS, AS AN EXPORT.
+ *
+ * `hosts/{hostId}/formSubmissions/{id}`, written only by this plugin's door
+ * (`server/form-submit.ts`): the answers a visitor sent, keyed by the form
+ * field's `fieldName`, with when, from which page and through which form.
+ * The record as a reader may rely on it is `model/form-submission-record.ts`'s;
+ * this module reads it the same way.
+ *
+ * ## Export only
+ *
+ * The declaration carries `exportOnly`: a submission is what a visitor sent
+ * through a published form, and a file cannot have sent one. So the resource
+ * answers the catalog, the reads, the count and a lookup by id, and registers
+ * no `apply` or `revert` — the upload route refuses it before a byte is
+ * stored.
+ *
+ * ## The columns follow the form
+ *
+ * A submission's answers have no fixed shape: each form asks its own
+ * questions, and a form edited since asks different ones than its older
+ * submissions answered. So the catalog is read from the site's forms, and
+ * from the list filter the dialog was opened on (`ctx.filter`):
+ *
+ *  - one form (`{ formId }`): that form's questions, each `answer:<fieldName>`,
+ *    labeled with the question and typed from the field; then "Other
+ *    answers" — keys its most recent submissions carry and today's form no
+ *    longer declares, so an answer to a removed question is still exported.
+ *  - the whole site: every form's questions, each form its own group. A
+ *    `fieldName` two forms share is one column (the first form's label), so
+ *    an "email" asked by every form lands in one place.
+ *
+ * The submission's own details — the Aglyn ID, when it arrived, the form, the
+ * page, read, replied, campaigns, where it was filed — are read-only, and the
+ * platform-written ones are `system`.
+ *
+ * ## The reads are queries, never a loaded window
+ *
+ * `{ formId }` and `{ read }` are equalities on the stored row, ordered by
+ * `createdAt` newest first with the document id breaking ties, so a page
+ * boundary between two submissions of the same instant neither repeats nor
+ * skips one. `formId ↑ createdAt ↓` and `read ↑ createdAt ↓` are the
+ * collection's existing indexes (the console's per-form list and the Inbox's
+ * Read filter); no filter rides the single-field `createdAt` index. Both at
+ * once needs `formId ↑ read ↑ createdAt ↓`, which the export dialog never
+ * asks for today.
+ *
+ * ## Scope
+ *
+ * A host resource: the export route admits a reader only on the site, with
+ * `data.manage` there. Submissions carry no `visibleTo`, so `scopeTokens` —
+ * a site-scoped collaborator's tokens — narrows nothing here: a collaborator
+ * the route let onto this site may read this site's submissions, as the
+ * Inbox lets them.
+ *=========================================*/ const SUBMISSIONS = 'formSubmissions';
+const FORMS = 'forms';
+/** The prefix of an answer's field id; the rest is the form field's `fieldName`. */ export const FORM_SUBMISSION_ANSWER_PREFIX = 'answer:';
+/** How many of the most recent submissions the catalog reads for answers today's forms no longer ask. */ export const FORM_SUBMISSIONS_ANSWER_SAMPLE_ROWS = 200;
+/**
+ * The most "other answers" columns the catalog offers. A submission's keys
+ * come from the visitor's request (up to twenty, each at most 64 characters),
+ * so a sample can hold keys no form ever asked; the most frequent are kept.
+ */ export const FORM_SUBMISSIONS_OTHER_ANSWERS_MAX = 50;
+const PAGE_ROWS_DEFAULT = 200;
+const PAGE_ROWS_MAX = 500;
+/** Documents one `getAll` reads at a time, for a selection. */ const READ_BY_ID_CHUNK = 300;
+/** The group the submission's own details are listed under. */ export const FORM_SUBMISSION_DETAILS_GROUP = {
+    id: 'submission',
+    label: 'Submission'
+};
+/** The group of answers no form declares today. */ export const FORM_SUBMISSION_OTHER_ANSWERS_GROUP = {
+    id: 'otherAnswers',
+    label: 'Other answers'
+};
+/** A form's questions are listed under `form:<formId>`. */ export function formAnswersGroupId(formId) {
+    return `form:${formId}`;
+}
+/** The field id an answer to `fieldName` is exported under. */ export function formSubmissionAnswerFieldId(fieldName) {
+    return `${FORM_SUBMISSION_ANSWER_PREFIX}${fieldName}`;
+}
+/** What an answer is, from the form field that asked it. */ export function formAnswerTransferType(fieldType) {
+    switch(fieldType){
+        case 'email':
+            return 'email';
+        case 'textarea':
+            return 'longText';
+        case 'rating':
+            return 'integer';
+        default:
+            return 'text';
+    }
+}
+/**
+ * The filter a dialog or a route handed over, or why it cannot be used.
+ * Refused rather than ignored: a filter dropped without a word exports more
+ * than the person asked for.
+ */ export function readFormSubmissionsFilter(value) {
+    if (value === null || value === undefined) return {};
+    if (typeof value !== 'object' || Array.isArray(value)) {
+        throw new Error('A form submissions filter is an object naming formId and read.');
+    }
+    const filter = {};
+    for (const [key, raw] of Object.entries(value)){
+        if (raw === undefined || raw === null) continue;
+        if (key === 'formId') {
+            const formId = typeof raw === 'string' ? raw.trim() : '';
+            if (!formId || formId.includes('/')) throw new Error('The form submissions filter names no usable form.');
+            filter.formId = formId;
+        } else if (key === 'read') {
+            if (raw === true || raw === 'true') filter.read = true;
+            else if (raw === false || raw === 'false') filter.read = false;
+            else throw new Error('The form submissions filter says read as true or false.');
+        } else {
+            throw new Error(`A form submissions filter names formId and read; "${key}" is not one.`);
+        }
+    }
+    return filter;
+}
+function matchesFilter(data, filter) {
+    if (filter.formId !== undefined && data['formId'] !== filter.formId) return false;
+    if (filter.read !== undefined && data['read'] === true !== filter.read) return false;
+    return true;
+}
+/*==========================================
+ * THE CATALOG
+ *=========================================*/ /** The submission's own details, in the order a person reads them. */ export function formSubmissionDetailFields() {
+    const group = FORM_SUBMISSION_DETAILS_GROUP.id;
+    return [
+        _extends({}, transferIdField(), {
+            group
+        }),
+        {
+            id: 'createdAt',
+            label: 'Submitted at',
+            group,
+            type: 'datetime',
+            readOnly: true,
+            system: true,
+            aliases: [
+                'submitted',
+                'created',
+                'date'
+            ],
+            description: 'When the submission arrived, by the server’s clock.'
+        },
+        {
+            id: 'formId',
+            label: 'Form ID',
+            group,
+            type: 'text',
+            readOnly: true,
+            system: true,
+            description: 'The form it was sent through; blank on submissions older than the form itself.'
+        },
+        {
+            id: 'formName',
+            label: 'Form name',
+            group,
+            type: 'text',
+            readOnly: true,
+            system: true,
+            aliases: [
+                'form'
+            ],
+            description: 'What the form was called when the submission arrived.'
+        },
+        {
+            id: 'path',
+            label: 'Page path',
+            group,
+            type: 'text',
+            readOnly: true,
+            system: true,
+            aliases: [
+                'page',
+                'path'
+            ],
+            description: 'The page of the site it was sent from.'
+        },
+        {
+            id: 'read',
+            label: 'Read',
+            group,
+            type: 'boolean',
+            readOnly: true,
+            description: 'Whether someone has marked it read in the Inbox.'
+        },
+        {
+            id: 'repliedAt',
+            label: 'Replied at',
+            group,
+            type: 'datetime',
+            readOnly: true,
+            description: 'When it was last answered from the Inbox.'
+        },
+        {
+            id: 'campaignIds',
+            label: 'Campaign IDs',
+            group,
+            type: 'tags',
+            readOnly: true,
+            system: true,
+            description: 'The campaigns the form was filed under when the submission arrived.'
+        },
+        {
+            id: 'routing',
+            label: 'Where it was filed',
+            group,
+            type: 'json',
+            readOnly: true,
+            system: true,
+            description: 'Where the submission was also filed beyond the Inbox, such as a dataset, or why it was not.'
+        },
+        {
+            id: 'rateDegraded',
+            label: 'Arrived while rate limits were unchecked',
+            group,
+            type: 'boolean',
+            readOnly: true,
+            system: true,
+            description: 'Yes when it arrived during a moment the site’s submission rate limit could not be checked.'
+        },
+        {
+            id: 'hostId',
+            label: 'Site ID',
+            group,
+            type: 'text',
+            readOnly: true,
+            system: true
+        }
+    ];
+}
+function formQuestionsOf(id, data) {
+    const declared = Array.isArray(data == null ? void 0 : data['fields']) ? data == null ? void 0 : data['fields'] : [];
+    const displayName = data == null ? void 0 : data['displayName'];
+    return {
+        id,
+        name: typeof displayName === 'string' && displayName.trim() ? displayName.trim() : id,
+        fields: declared.filter((field)=>Boolean(field) && typeof field === 'object' && typeof field.fieldName === 'string' && field.fieldName.trim() !== '')
+    };
+}
+function answerField(decl, group) {
+    const label = typeof decl.label === 'string' && decl.label.trim() ? decl.label.trim() : decl.fieldName;
+    return _extends({
+        id: formSubmissionAnswerFieldId(decl.fieldName),
+        label,
+        group,
+        type: formAnswerTransferType(decl.fieldType)
+    }, label !== decl.fieldName ? {
+        aliases: [
+            decl.fieldName
+        ]
+    } : {});
+}
+/**
+ * The catalog, from the forms read and the answer keys sampled (see the
+ * block header). `scoped` is true when the dialog was opened on one form.
+ */ export function formSubmissionsCatalog(input) {
+    const answers = [];
+    const groups = [
+        FORM_SUBMISSION_DETAILS_GROUP
+    ];
+    const taken = new Set();
+    for (const form of input.forms){
+        const group = {
+            id: formAnswersGroupId(form.id),
+            label: input.scoped ? 'Answers' : `Answers: ${form.name}`
+        };
+        let added = false;
+        for (const decl of form.fields){
+            if (taken.has(decl.fieldName)) continue;
+            taken.add(decl.fieldName);
+            answers.push(answerField(decl, group.id));
+            added = true;
+        }
+        if (added) groups.push(group);
+    }
+    const others = input.sampledKeys.filter((key)=>!taken.has(key)).slice(0, FORM_SUBMISSIONS_OTHER_ANSWERS_MAX);
+    for (const key of others){
+        answers.push({
+            id: formSubmissionAnswerFieldId(key),
+            label: key,
+            group: FORM_SUBMISSION_OTHER_ANSWERS_GROUP.id,
+            type: 'text',
+            description: input.scoped ? 'An answer earlier submissions to this form carry that the form no longer asks for.' : 'An answer earlier submissions carry that no form on this site asks for today.'
+        });
+    }
+    if (others.length) groups.push(FORM_SUBMISSION_OTHER_ANSWERS_GROUP);
+    return {
+        standard: [
+            ...formSubmissionDetailFields(),
+            ...answers
+        ],
+        groups
+    };
+}
+/** The answer keys the sampled submissions carry, most frequent first, then first seen. */ export function sampledAnswerKeys(rows) {
+    const seen = new Map();
+    for (const data of rows){
+        const fields = data == null ? void 0 : data['fields'];
+        if (!fields || typeof fields !== 'object' || Array.isArray(fields)) continue;
+        for (const key of Object.keys(fields)){
+            if (!key.trim()) continue;
+            const entry = seen.get(key);
+            if (entry) entry.count += 1;
+            else seen.set(key, {
+                count: 1,
+                order: seen.size
+            });
+        }
+    }
+    return [
+        ...seen.entries()
+    ].sort(([, a], [, b])=>b.count - a.count || a.order - b.order).map(([key])=>key);
+}
+/*==========================================
+ * ONE ROW
+ *=========================================*/ function textOrNull(value) {
+    return typeof value === 'string' && value !== '' ? value : null;
+}
+/** A stored instant as ISO text, so a CSV reads it: a Firestore Timestamp, a Date, or milliseconds. */ function isoOf(value) {
+    if (value === null || value === undefined) return null;
+    if (typeof value === 'number') return Number.isFinite(value) ? new Date(value).toISOString() : null;
+    if (value instanceof Date) return Number.isNaN(value.getTime()) ? null : value.toISOString();
+    const toDate = value.toDate;
+    if (typeof toDate === 'function') return isoOf(toDate.call(value));
+    return null;
+}
+const DETAIL_READERS = {
+    [TRANSFER_ID_FIELD]: (_data, id)=>id,
+    createdAt: (data)=>isoOf(data['createdAt']),
+    formId: (data)=>textOrNull(data['formId']),
+    formName: (data)=>textOrNull(data['formName']),
+    path: (data)=>textOrNull(data['path']),
+    read: (data)=>data['read'] === true,
+    repliedAt: (data)=>isoOf(data['repliedAtMs']),
+    campaignIds: (data)=>Array.isArray(data['campaignIds']) ? data['campaignIds'].filter((one)=>typeof one === 'string' && one !== '') : [],
+    routing: (data)=>data['routing'] && typeof data['routing'] === 'object' && !Array.isArray(data['routing']) ? data['routing'] : null,
+    rateDegraded: (data)=>data['rateDegraded'] === true,
+    hostId: (data)=>textOrNull(data['hostId'])
+};
+/** The rating questions of each form (AGL-3548). */ export function formRatingQuestions(forms) {
+    return new Map(forms.map((form)=>[
+            form.id,
+            new Set(form.fields.filter((field)=>field.fieldType === 'rating').map((field)=>field.fieldName))
+        ]));
+}
+const RATING_TEXT = /^-?\d+(?:\.\d+)?$/;
+/**
+ * One submission as an export row: only `fieldIds`, keyed by field id. An
+ * answer is the value as the visitor sent it — but an answer to a rating
+ * question of the submission's form (`ratings`) that reads as a number is
+ * that number, so a JSON file holds `4` and a CSV writes it as one, not as
+ * text. A question they did not answer, or a field id this resource does
+ * not know, is `null`.
+ */ export function formSubmissionTransferRow(id, data, fieldIds, ratings) {
+    const answers = data['fields'] && typeof data['fields'] === 'object' && !Array.isArray(data['fields']) ? data['fields'] : {};
+    const formId = typeof data['formId'] === 'string' ? data['formId'] : '';
+    const rated = ratings == null ? void 0 : ratings.get(formId);
+    const row = {};
+    for (const fieldId of fieldIds){
+        const reader = DETAIL_READERS[fieldId];
+        if (reader) row[fieldId] = reader(data, id);
+        else if (fieldId.startsWith(FORM_SUBMISSION_ANSWER_PREFIX)) {
+            const name = fieldId.slice(FORM_SUBMISSION_ANSWER_PREFIX.length);
+            const answer = answers[name];
+            row[fieldId] = answer === undefined ? null : (rated == null ? void 0 : rated.has(name)) && typeof answer === 'string' && RATING_TEXT.test(answer.trim()) ? Number(answer.trim()) : answer;
+        } else row[fieldId] = null;
+    }
+    return row;
+}
+/*==========================================
+ * THE CURSOR
+ *=========================================*/ /**
+ * Where the next page of a query starts: the last row's `createdAt` (seconds
+ * and nanoseconds, so two submissions a microsecond apart stay apart) and
+ * its id. A selection's cursor is the offset into the ids.
+ */ export function formSubmissionsCursor(createdAt, id) {
+    const at = createdAt;
+    if (typeof (at == null ? void 0 : at.seconds) !== 'number' || typeof (at == null ? void 0 : at.nanoseconds) !== 'number') {
+        throw new Error(`Form submission ${id} has no submission time to page from.`);
+    }
+    return `${at.seconds}:${at.nanoseconds}:${id}`;
+}
+function readQueryCursor(cursor) {
+    const found = /^(-?\d+):(\d+):([^]+)$/.exec(cursor);
+    if (!found) throw new Error('The export cursor could not be read.');
+    return {
+        createdAt: new Timestamp(Number(found[1]), Number(found[2])),
+        id: found[3]
+    };
+}
+function readOffsetCursor(cursor) {
+    if (cursor === null) return 0;
+    if (!/^\d+$/.test(cursor)) throw new Error('The export cursor could not be read.');
+    return Number(cursor);
+}
+function pageSizeOf(options) {
+    const asked = Math.floor(Number(options == null ? void 0 : options.pageSize) || PAGE_ROWS_DEFAULT);
+    return Math.max(1, Math.min(PAGE_ROWS_MAX, asked));
+}
+/** The ids of a selection, each once, in the order given. */ function selectionIds(ids) {
+    return [
+        ...new Set(ids.filter((id)=>typeof id === 'string' && id !== '' && !id.includes('/')))
+    ];
+}
+/**
+ * The form submissions resource's server half (see the block header).
+ * Firestore is handed in, so a spec runs it over an in-memory one.
+ */ export function createFormSubmissionsTransferResource(deps) {
+    const { firestore } = deps;
+    const site = (hostId)=>firestore.collection('hosts').doc(hostId);
+    const submissions = (hostId)=>site(hostId).collection(SUBMISSIONS);
+    /** The filter as Firestore equalities, over the collection's existing indexes. */ const filtered = (hostId, filter)=>{
+        let query = submissions(hostId);
+        if (filter.formId !== undefined) query = query.where('formId', '==', filter.formId);
+        if (filter.read !== undefined) query = query.where('read', '==', filter.read);
+        return query;
+    };
+    const newestFirst = (query)=>query.orderBy('createdAt', 'desc').orderBy(FieldPath.documentId(), 'desc');
+    /** The selection's documents that exist and keep the filter, in the order given. */ const readByIds = async (hostId, ids, filter)=>{
+        const found = [];
+        for(let at = 0; at < ids.length; at += READ_BY_ID_CHUNK){
+            const refs = ids.slice(at, at + READ_BY_ID_CHUNK).map((id)=>submissions(hostId).doc(id));
+            if (!refs.length) continue;
+            const snapshots = await firestore.getAll(...refs);
+            for (const snapshot of snapshots){
+                const data = snapshot.data();
+                if (snapshot.exists && data && matchesFilter(data, filter)) found.push(snapshot);
+            }
+        }
+        return found;
+    };
+    const readForms = async (hostId, formId)=>{
+        if (formId !== undefined) {
+            const snapshot = await site(hostId).collection(FORMS).doc(formId).get();
+            return snapshot.exists ? [
+                formQuestionsOf(snapshot.id, snapshot.data())
+            ] : [];
+        }
+        const snapshot = await site(hostId).collection(FORMS).limit(FORMS_MAX_PER_HOST).get();
+        return snapshot.docs.map((document)=>formQuestionsOf(document.id, document.data())).sort((a, b)=>a.name.localeCompare(b.name) || a.id.localeCompare(b.id));
+    };
+    const readPage = async (ctx, cursor, fieldIds, options)=>{
+        const hostId = ctx.hostId;
+        if (!hostId) return {
+            rows: [],
+            next: null
+        };
+        const filter = readFormSubmissionsFilter(options == null ? void 0 : options.filter);
+        const size = pageSizeOf(options);
+        // Which answers are ratings, read only when an answer is asked for.
+        const ratings = fieldIds.some((fieldId)=>fieldId.startsWith(FORM_SUBMISSION_ANSWER_PREFIX)) ? formRatingQuestions(await readForms(hostId, filter.formId)) : undefined;
+        if (options == null ? void 0 : options.ids) {
+            const ids = selectionIds(options.ids);
+            const from = readOffsetCursor(cursor);
+            const to = from + size;
+            const snapshots = await readByIds(hostId, ids.slice(from, to), filter);
+            return {
+                rows: snapshots.map((snapshot)=>{
+                    var _snapshot_data;
+                    return formSubmissionTransferRow(snapshot.id, (_snapshot_data = snapshot.data()) != null ? _snapshot_data : {}, fieldIds, ratings);
+                }),
+                next: to < ids.length ? String(to) : null
+            };
+        }
+        let query = newestFirst(filtered(hostId, filter));
+        if (cursor !== null) {
+            const after = readQueryCursor(cursor);
+            query = query.startAfter(after.createdAt, after.id);
+        }
+        // One past the page, so the last page says it is the last.
+        const snapshot = await query.limit(size + 1).get();
+        const page = snapshot.docs.slice(0, size);
+        const last = page[page.length - 1];
+        return {
+            rows: page.map((document)=>formSubmissionTransferRow(document.id, document.data(), fieldIds, ratings)),
+            next: snapshot.docs.length > size && last ? formSubmissionsCursor(last.get('createdAt'), last.id) : null
+        };
+    };
+    return {
+        matchKeys: FORM_SUBMISSIONS_MATCH_KEYS,
+        async fields (ctx) {
+            const hostId = ctx.hostId;
+            if (!hostId) return formSubmissionsCatalog({
+                forms: [],
+                sampledKeys: [],
+                scoped: false
+            });
+            const { formId } = readFormSubmissionsFilter(ctx.filter);
+            const [forms, sample] = await Promise.all([
+                readForms(hostId, formId),
+                newestFirst(filtered(hostId, formId === undefined ? {} : {
+                    formId
+                })).limit(FORM_SUBMISSIONS_ANSWER_SAMPLE_ROWS).get()
+            ]);
+            return formSubmissionsCatalog({
+                forms,
+                sampledKeys: sampledAnswerKeys(sample.docs.map((document)=>document.data())),
+                scoped: formId !== undefined
+            });
+        },
+        async count (ctx, options) {
+            const hostId = ctx.hostId;
+            if (!hostId) return 0;
+            const filter = readFormSubmissionsFilter(options.filter);
+            if (options.ids) return (await readByIds(hostId, selectionIds(options.ids), filter)).length;
+            const counted = await filtered(hostId, filter).count().get();
+            return counted.data().count;
+        },
+        readPage,
+        /**
+     * What a submission holds now, by its Aglyn ID — the one key this
+     * resource answers, since nothing ever imports into it.
+     */ async lookup (ctx, requests) {
+            const byId = requests.filter((request)=>request.fieldId === TRANSFER_ID_FIELD);
+            const ids = byId.flatMap((request)=>request.values);
+            const found = ctx.hostId ? await readByIds(ctx.hostId, selectionIds(ids), {}) : [];
+            const records = new Map();
+            for (const document of found){
+                var _document_data;
+                const data = (_document_data = document.data()) != null ? _document_data : {};
+                const answers = data['fields'] && typeof data['fields'] === 'object' ? Object.keys(data['fields']) : [];
+                records.set(document.id, formSubmissionTransferRow(document.id, data, [
+                    ...Object.keys(DETAIL_READERS),
+                    ...answers.map(formSubmissionAnswerFieldId)
+                ]));
+            }
+            const lookup = buildMatchLookup([
+                ...records
+            ].map(([id, values])=>({
+                    id,
+                    values
+                })), byId);
+            return {
+                lookup,
+                records
+            };
+        }
+    };
+}
+
+//# sourceMappingURL=form-submissions-transfer.js.map