backend-manager 5.0.103 → 5.0.105

package/test/helpers/{stripe-parse-webhook.js → payment/stripe/parse-webhook.js}

@@ -5,14 +5,14 @@
  * Verifies that parseWebhook() correctly determines category, resourceType, resourceId,
  * and uid for each supported event type. Uses real Stripe CLI fixtures where available.
  */
-const stripeProcessor = require('../../src/manager/routes/payments/webhook/processors/stripe.js');
+const stripeProcessor = require('../../../../src/manager/routes/payments/webhook/processors/stripe.js');
 
 // Real Stripe CLI fixtures
-const FIXTURE_INVOICE_MANUAL = require('../fixtures/stripe/invoice-payment-failed.json');
-const FIXTURE_CHECKOUT_PAYMENT = require('../fixtures/stripe/checkout-session-completed.json');
+const FIXTURE_INVOICE_MANUAL = require('../../../fixtures/stripe/invoice-payment-failed.json');
+const FIXTURE_CHECKOUT_PAYMENT = require('../../../fixtures/stripe/checkout-session-completed.json');
 
 // Hand-crafted fixture (subscription-related invoice failure)
-const FIXTURE_INVOICE_SUB = require('../fixtures/stripe/invoice-subscription-payment-failed.json');
+const FIXTURE_INVOICE_SUB = require('../../../fixtures/stripe/invoice-subscription-payment-failed.json');
 
 function parseWebhook(event) {
   return stripeProcessor.parseWebhook({ body: event });

package/test/helpers/{stripe-to-unified-one-time.js → payment/stripe/to-unified-one-time.js}

@@ -4,24 +4,26 @@
  *
  * Tests the pure function directly — no emulator, no Firestore, no HTTP
  */
-const Stripe = require('../../src/manager/libraries/payment-processors/stripe.js');
+const Stripe = require('../../../../src/manager/libraries/payment/processors/stripe.js');
 
 // Real Stripe CLI fixtures (generated via `stripe trigger`)
-const FIXTURE_SESSION = require('../fixtures/stripe/checkout-session-completed.json');
-const FIXTURE_INVOICE_FAILED = require('../fixtures/stripe/invoice-payment-failed.json');
+const FIXTURE_SESSION = require('../../../fixtures/stripe/checkout-session-completed.json');
+const FIXTURE_INVOICE_FAILED = require('../../../fixtures/stripe/invoice-payment-failed.json');
 
-// Mock config matching the BEM template
+// Mock config matching the BEM template (new flat price structure)
 const MOCK_CONFIG = {
   payment: {
     products: [
       { id: 'basic', name: 'Basic', type: 'subscription', limits: { requests: 100 } },
       {
         id: 'credits-100', name: '100 Credits', type: 'one-time',
-        prices: { once: { amount: 9.99, stripe: 'price_credits_100' } },
+        prices: { once: 9.99 },
+        stripe: { productId: 'prod_credits_100' },
       },
       {
         id: 'credits-500', name: '500 Credits', type: 'one-time',
-        prices: { once: { amount: 39.99, stripe: 'price_credits_500' } },
+        prices: { once: 39.99 },
+        stripe: { productId: 'prod_credits_500' },
       },
     ],
   },

package/test/helpers/{stripe-to-unified.js → payment/stripe/to-unified-subscription.js}

@@ -4,31 +4,27 @@
  *
  * Tests the pure function directly — no emulator, no Firestore, no HTTP
  */
-const Stripe = require('../../src/manager/libraries/payment-processors/stripe.js');
+const Stripe = require('../../../../src/manager/libraries/payment/processors/stripe.js');
 
 // Real Stripe CLI fixtures (generated via `stripe trigger`)
-const FIXTURE_ACTIVE = require('../fixtures/stripe/subscription-active.json');
-const FIXTURE_CANCELED = require('../fixtures/stripe/subscription-canceled.json');
-const FIXTURE_TRIALING = require('../fixtures/stripe/subscription-trialing.json');
+const FIXTURE_ACTIVE = require('../../../fixtures/stripe/subscription-active.json');
+const FIXTURE_CANCELED = require('../../../fixtures/stripe/subscription-canceled.json');
+const FIXTURE_TRIALING = require('../../../fixtures/stripe/subscription-trialing.json');
 
-// Mock config matching the BEM template
+// Mock config matching the BEM template (new flat price structure)
 const MOCK_CONFIG = {
   payment: {
     products: [
       { id: 'basic', name: 'Basic', type: 'subscription', limits: { requests: 100 } },
       {
         id: 'plus', name: 'Plus', type: 'subscription',
-        prices: {
-          monthly: { amount: 9.99, stripe: 'price_plus_monthly' },
-          annually: { amount: 99.99, stripe: 'price_plus_annually' },
-        },
+        prices: { monthly: 9.99, annually: 99.99 },
+        stripe: { productId: 'prod_plus' },
       },
       {
         id: 'pro', name: 'Pro', type: 'subscription',
-        prices: {
-          monthly: { amount: 29.99, stripe: 'price_pro_monthly' },
-          annually: { amount: 299.99, stripe: 'price_pro_annually' },
-        },
+        prices: { monthly: 29.99, annually: 299.99 },
+        stripe: { productId: 'prod_pro', legacyProductIds: ['prod_pro_old'] },
       },
     ],
   },
@@ -112,18 +108,18 @@ module.exports = {
     // ─── Product resolution ───
 
     {
-      name: 'product-resolves-monthly-price',
+      name: 'product-resolves-from-plan-product',
       async run({ assert }) {
-        const result = toUnifiedSubscription({ plan: { id: 'price_plus_monthly' } });
+        const result = toUnifiedSubscription({ plan: { product: 'prod_plus' } });
         assert.equal(result.product.id, 'plus', 'Should resolve to plus');
         assert.equal(result.product.name, 'Plus', 'Should have correct name');
       },
     },
 
     {
-      name: 'product-resolves-annual-price',
+      name: 'product-resolves-pro-from-plan-product',
       async run({ assert }) {
-        const result = toUnifiedSubscription({ plan: { id: 'price_pro_annually' } });
+        const result = toUnifiedSubscription({ plan: { product: 'prod_pro' } });
         assert.equal(result.product.id, 'pro', 'Should resolve to pro');
         assert.equal(result.product.name, 'Pro', 'Should have correct name');
       },
@@ -133,18 +129,29 @@ module.exports = {
       name: 'product-resolves-from-items-array',
       async run({ assert }) {
         const result = toUnifiedSubscription({
-          items: { data: [{ price: { id: 'price_plus_monthly' } }] },
+          items: { data: [{ price: { product: 'prod_plus' } }] },
         });
-        assert.equal(result.product.id, 'plus', 'Should resolve from items.data[0].price.id');
+        assert.equal(result.product.id, 'plus', 'Should resolve from items.data[0].price.product');
       },
     },
 
     {
-      name: 'product-falls-back-to-basic-on-unknown-price',
+      name: 'product-resolves-legacy-product-id',
       async run({ assert }) {
-        const result = toUnifiedSubscription({ plan: { id: 'price_nonexistent' } });
-        assert.equal(result.product.id, 'basic', 'Unknown price → basic');
-        assert.equal(result.product.name, 'Basic', 'Unknown price → Basic name');
+        const result = toUnifiedSubscription({
+          items: { data: [{ price: { product: 'prod_pro_old' } }] },
+        });
+        assert.equal(result.product.id, 'pro', 'Legacy product ID → pro');
+        assert.equal(result.product.name, 'Pro', 'Legacy product ID → Pro name');
+      },
+    },
+
+    {
+      name: 'product-falls-back-to-basic-on-unknown-product',
+      async run({ assert }) {
+        const result = toUnifiedSubscription({ plan: { product: 'prod_nonexistent' } });
+        assert.equal(result.product.id, 'basic', 'Unknown product → basic');
+        assert.equal(result.product.name, 'Basic', 'Unknown product → Basic name');
       },
     },
 
@@ -159,7 +166,7 @@ module.exports = {
     {
       name: 'product-falls-back-to-basic-without-config',
       async run({ assert }) {
-        const result = Stripe.toUnifiedSubscription({ plan: { id: 'price_plus_monthly' } }, {});
+        const result = Stripe.toUnifiedSubscription({ plan: { product: 'prod_plus' } }, {});
         assert.equal(result.product.id, 'basic', 'No config → basic');
       },
     },
@@ -408,7 +415,7 @@ module.exports = {
         const result = toUnifiedSubscription({
           id: 'sub_full_test',
           status: 'active',
-          plan: { id: 'price_pro_monthly', interval: 'month' },
+          plan: { product: 'prod_pro', interval: 'month' },
           current_period_end: now + 86400 * 30,
           current_period_start: now,
           start_date: now - 86400 * 60,
@@ -488,9 +495,9 @@ module.exports = {
     {
       name: 'fixture-active-product-falls-back',
       async run({ assert }) {
-        // Fixture price IDs won't match our mock config, so it should fall back to basic
+        // Fixture product IDs won't match our mock config, so it should fall back to basic
         const result = toUnifiedSubscription(FIXTURE_ACTIVE);
-        assert.equal(result.product.id, 'basic', 'Unknown price → basic fallback');
+        assert.equal(result.product.id, 'basic', 'Unknown product → basic fallback');
       },
     },
 
@@ -576,7 +583,7 @@ module.exports = {
           canceled_at: null,
           current_period_end: now + 86400 * 11,
           start_date: now - 86400 * 3,
-          plan: { id: 'price_plus_monthly', interval: 'month' },
+          plan: { product: 'prod_plus', interval: 'month' },
         });
 
         assert.equal(result.status, 'active', 'Trialing + cancel → still active');
@@ -599,7 +606,7 @@ module.exports = {
           canceled_at: now,
           current_period_end: now - 86400,
           start_date: now - 86400 * 14,
-          plan: { id: 'price_plus_monthly', interval: 'month' },
+          plan: { product: 'prod_plus', interval: 'month' },
         });
 
         assert.equal(result.status, 'cancelled', 'Failed trial → cancelled');
@@ -622,7 +629,7 @@ module.exports = {
           canceled_at: null,
           current_period_end: now + 86400 * 14,
           start_date: now - 86400 * 30,
-          plan: { id: 'price_pro_monthly', interval: 'month' },
+          plan: { product: 'prod_pro', interval: 'month' },
         });
 
         assert.equal(result.status, 'active', 'Active with past trial → active');
@@ -646,7 +653,7 @@ module.exports = {
           start_date: now - 86400 * 40,
           trial_start: null,
           trial_end: null,
-          plan: { id: 'price_pro_monthly', interval: 'month' },
+          plan: { product: 'prod_pro', interval: 'month' },
         });
 
         assert.equal(result.status, 'active', 'Reactivated → active');
@@ -668,7 +675,7 @@ module.exports = {
           start_date: now - 86400 * 60,
           trial_start: null,
           trial_end: null,
-          plan: { id: 'price_plus_monthly', interval: 'month' },
+          plan: { product: 'prod_plus', interval: 'month' },
         });
 
         assert.equal(result.status, 'suspended', 'Past due → suspended');
@@ -689,7 +696,7 @@ module.exports = {
           canceled_at: null,
           current_period_end: now + 86400,
           start_date: now - 86400 * 14,
-          plan: { id: 'price_plus_monthly', interval: 'month' },
+          plan: { product: 'prod_plus', interval: 'month' },
         });
 
         assert.equal(result.status, 'suspended', 'Trial ended + payment failed → suspended');

package/test/routes/payments/refund.js

@@ -0,0 +1,174 @@
+/**
+ * Test: POST /payments/refund
+ * Tests rejection cases and a full end-to-end refund flow with the test processor.
+ *
+ * Refund requires the subscription to be cancelled or pending cancellation.
+ * The test processor simulates refund by writing a customer.subscription.deleted
+ * webhook which triggers the existing pipeline.
+ */
+module.exports = {
+  description: 'Payment refund endpoint',
+  type: 'group',
+  timeout: 30000,
+
+  tests: [
+    {
+      name: 'rejects-unauthenticated',
+      async run({ http, assert }) {
+        const response = await http.as('none').post('payments/refund', {
+          confirmed: true,
+          reason: 'Too expensive',
+        });
+
+        assert.isError(response, 401, 'Should reject unauthenticated request');
+      },
+    },
+
+    {
+      name: 'rejects-missing-confirmed',
+      async run({ http, assert }) {
+        const response = await http.as('basic').post('payments/refund', {
+          reason: 'Too expensive',
+        });
+
+        assert.isError(response, 400, 'Should reject missing confirmed field');
+      },
+    },
+
+    {
+      name: 'rejects-missing-reason',
+      async run({ http, assert }) {
+        const response = await http.as('basic').post('payments/refund', {
+          confirmed: true,
+        });
+
+        assert.isError(response, 400, 'Should reject missing reason field');
+      },
+    },
+
+    {
+      name: 'rejects-basic-user',
+      async run({ http, assert }) {
+        const response = await http.as('basic').post('payments/refund', {
+          confirmed: true,
+          reason: 'Too expensive',
+        });
+
+        assert.isError(response, 400, 'Should reject basic user with no paid subscription');
+      },
+    },
+
+    {
+      name: 'rejects-active-subscription-without-cancellation',
+      async run({ http, assert }) {
+        // refund-active-no-cancel has an active subscription without pending cancellation
+        const response = await http.as('refund-active-no-cancel').post('payments/refund', {
+          confirmed: true,
+          reason: 'Too expensive',
+        });
+
+        assert.isError(response, 400, 'Should reject active subscription that is not cancelled or pending cancellation');
+      },
+    },
+
+    {
+      name: 'rejects-payment-older-than-6-months',
+      async run({ http, assert }) {
+        // refund-expired-payment has a cancelled subscription with a payment older than 6 months
+        const response = await http.as('refund-expired-payment').post('payments/refund', {
+          confirmed: true,
+          reason: 'Too expensive',
+        });
+
+        assert.isError(response, 400, 'Should reject payment older than 6 months');
+      },
+    },
+
+    {
+      name: 'rejects-no-processor-or-resource-id',
+      async run({ http, assert }) {
+        // refund-no-processor has a cancelled subscription but no processor
+        const response = await http.as('refund-no-processor').post('payments/refund', {
+          confirmed: true,
+          reason: 'Too expensive',
+        });
+
+        assert.isError(response, 400, 'Should reject when no processor or resourceId is set');
+      },
+    },
+
+    {
+      name: 'rejects-unknown-processor',
+      async run({ http, assert }) {
+        // refund-unknown-processor has a cancelled subscription with unknown processor
+        const response = await http.as('refund-unknown-processor').post('payments/refund', {
+          confirmed: true,
+          reason: 'Too expensive',
+        });
+
+        assert.isError(response, 400, 'Should reject unknown processor');
+      },
+    },
+
+    {
+      name: 'succeeds-with-test-processor',
+      async run({ http, assert, config, accounts, firestore, waitFor }) {
+        const uid = accounts['route-refund-success'].uid;
+        const paidProduct = config.payment.products.find(p => p.id !== 'basic' && p.prices?.monthly);
+
+        // Step 1: Create a test subscription intent to set up a proper paid subscription
+        const intentResponse = await http.as('route-refund-success').post('payments/intent', {
+          processor: 'test',
+          productId: paidProduct.id,
+          frequency: 'monthly',
+        });
+
+        assert.isSuccess(intentResponse, 'Intent should succeed');
+
+        // Wait for the auto-webhook to activate the subscription
+        await waitFor(async () => {
+          const userDoc = await firestore.get(`users/${uid}`);
+          return userDoc?.subscription?.payment?.processor === 'test'
+            && userDoc?.subscription?.payment?.resourceId
+            && userDoc?.subscription?.status === 'active';
+        }, 15000, 500);
+
+        // Step 2: Cancel the subscription first (refund requires cancellation)
+        const cancelResponse = await http.as('route-refund-success').post('payments/cancel', {
+          confirmed: true,
+          reason: 'Too expensive',
+        });
+
+        assert.isSuccess(cancelResponse, 'Cancel should succeed');
+
+        // Wait for cancellation.pending to be set via the webhook pipeline
+        await waitFor(async () => {
+          const userDoc = await firestore.get(`users/${uid}`);
+          return userDoc?.subscription?.cancellation?.pending === true;
+        }, 15000, 500);
+
+        // Step 3: Request a refund
+        const refundResponse = await http.as('route-refund-success').post('payments/refund', {
+          confirmed: true,
+          reason: 'Not satisfied with the service',
+          feedback: 'Testing refund flow',
+        });
+
+        assert.isSuccess(refundResponse, 'Refund should succeed');
+        assert.ok(refundResponse.data.success, 'Should return success: true');
+        assert.ok(refundResponse.data.refund, 'Should return refund details');
+        assert.isType(refundResponse.data.refund.amount, 'number', 'Refund amount should be a number');
+        assert.equal(refundResponse.data.refund.full, true, 'Should be a full refund (test processor)');
+
+        // Step 4: Verify subscription is cancelled via the webhook pipeline
+        await waitFor(async () => {
+          const userDoc = await firestore.get(`users/${uid}`);
+          return userDoc?.subscription?.status === 'cancelled';
+        }, 15000, 500);
+
+        const userDoc = await firestore.get(`users/${uid}`);
+        assert.equal(userDoc?.subscription?.status, 'cancelled', 'Subscription should be cancelled after refund');
+      },
+    },
+  ],
+};

package/src/manager/libraries/payment-processors/resolve-price-id.js

@@ -1,19 +0,0 @@
-/**
- * Resolve the Stripe price ID from a product config object
- *
- * @param {object} product - Product object from config (must have .prices)
- * @param {string} productType - 'subscription' or 'one-time'
- * @param {string} frequency - 'monthly', 'annually', etc. (subscriptions) — ignored for one-time
- * @returns {string} Stripe price ID
- * @throws {Error} If no price ID found
- */
-module.exports = function resolvePriceId(product, productType, frequency) {
-  const key = productType === 'subscription' ? frequency : 'once';
-  const priceId = product.prices?.[key]?.stripe;
-
-  if (!priceId) {
-    throw new Error(`No Stripe price found for ${product.id}/${key}`);
-  }
-
-  return priceId;
-};

package/src/manager/routes/forms/delete.js

@@ -1,37 +0,0 @@
-/**
- * DELETE /forms - Delete a form
- * Requires authentication and ownership.
- */
-module.exports = async ({ assistant, user, settings, analytics, libraries }) => {
-  const { admin } = libraries;
-
-  // Require authentication
-  if (!user.authenticated) {
-    return assistant.respond('Authentication required', { code: 401 });
-  }
-
-  if (!settings.id) {
-    return assistant.respond('Missing required parameter: id', { code: 400 });
-  }
-
-  const uid = user.auth.uid;
-  const formRef = admin.firestore().doc(`forms/${settings.id}`);
-  const doc = await formRef.get();
-
-  if (!doc.exists) {
-    return assistant.respond('Form not found', { code: 404 });
-  }
-
-  // Ownership check
-  if (doc.data().owner !== uid) {
-    return assistant.respond('Not authorized to delete this form', { code: 403 });
-  }
-
-  await formRef.delete();
-
-  assistant.log(`Deleted form ${settings.id} for user ${uid}`);
-
-  analytics.event('forms', { action: 'delete' });
-
-  return assistant.respond({ data: { deleted: true } });
-};

package/src/manager/routes/forms/get.js

@@ -1,46 +0,0 @@
-/**
- * GET /forms - Get a single form or list all forms for the authenticated user
- * Requires authentication.
- * - With ?id=xxx: returns a single form (with ownership check)
- * - Without id: returns all forms owned by the user
- */
-module.exports = async ({ assistant, user, settings, analytics, libraries }) => {
-  const { admin } = libraries;
-
-  // Require authentication
-  if (!user.authenticated) {
-    return assistant.respond('Authentication required', { code: 401 });
-  }
-
-  const uid = user.auth.uid;
-
-  // Single form
-  if (settings.id) {
-    const doc = await admin.firestore().doc(`forms/${settings.id}`).get();
-
-    if (!doc.exists) {
-      return assistant.respond('Form not found', { code: 404 });
-    }
-
-    if (doc.data().owner !== uid) {
-      return assistant.respond('Not authorized to view this form', { code: 403 });
-    }
-
-    analytics.event('forms', { action: 'get' });
-
-    return assistant.respond({ data: { form: doc.data() } });
-  }
-
-  // List all forms
-  const snapshot = await admin.firestore()
-    .collection('forms')
-    .where('owner', '==', uid)
-    .orderBy('created.timestampUNIX', 'desc')
-    .get();
-
-  const forms = snapshot.docs.map(doc => doc.data());
-
-  analytics.event('forms', { action: 'list' });
-
-  return assistant.respond({ data: { forms } });
-};

package/src/manager/routes/forms/post.js

@@ -1,45 +0,0 @@
-/**
- * POST /forms - Create a new form
- * Requires authentication. Creates a Firestore doc in the `forms` collection.
- */
-module.exports = async ({ assistant, Manager, user, settings, analytics, libraries }) => {
-  const { admin } = libraries;
-
-  // Require authentication
-  if (!user.authenticated) {
-    return assistant.respond('Authentication required', { code: 401 });
-  }
-
-  const uid = user.auth.uid;
-  const now = new Date().toISOString();
-  const nowUnix = Date.now();
-
-  // Generate a new document reference
-  const docRef = admin.firestore().collection('forms').doc();
-
-  const form = {
-    id: docRef.id,
-    owner: uid,
-    name: settings.name || 'Untitled Form',
-    description: settings.description || '',
-    settings: settings.settings || {},
-    pages: settings.pages || [],
-    created: {
-      timestamp: now,
-      timestampUNIX: nowUnix,
-    },
-    edited: {
-      timestamp: now,
-      timestampUNIX: nowUnix,
-    },
-    metadata: Manager.Metadata().set({ tag: 'forms/post' }),
-  };
-
-  await docRef.set(form);
-
-  assistant.log(`Created form ${docRef.id} for user ${uid}`);
-
-  analytics.event('forms', { action: 'create' });
-
-  return assistant.respond({ data: { id: docRef.id, form } });
-};

package/src/manager/routes/forms/public/get.js

@@ -1,37 +0,0 @@
-/**
- * GET /forms/public - Get a public form by ID
- * No authentication required. Only returns forms with settings.public = true.
- */
-module.exports = async ({ assistant, settings, analytics, libraries }) => {
-  const { admin } = libraries;
-
-  if (!settings.id) {
-    return assistant.respond('Missing required parameter: id', { code: 400 });
-  }
-
-  const doc = await admin.firestore().doc(`forms/${settings.id}`).get();
-
-  if (!doc.exists) {
-    return assistant.respond('Form not found', { code: 404 });
-  }
-
-  const form = doc.data();
-
-  // Only allow access to public forms
-  if (!form.settings?.public) {
-    return assistant.respond('Form not found', { code: 404 });
-  }
-
-  // Strip sensitive fields
-  const publicForm = {
-    id: form.id,
-    name: form.name,
-    description: form.description,
-    settings: form.settings,
-    pages: form.pages,
-  };
-
-  analytics.event('forms/public', { action: 'get' });
-
-  return assistant.respond({ payload: publicForm });
-};

package/src/manager/routes/forms/put.js

@@ -1,52 +0,0 @@
-/**
- * PUT /forms - Update an existing form
- * Requires authentication and ownership.
- */
-module.exports = async ({ assistant, Manager, user, settings, analytics, libraries }) => {
-  const { admin } = libraries;
-
-  // Require authentication
-  if (!user.authenticated) {
-    return assistant.respond('Authentication required', { code: 401 });
-  }
-
-  if (!settings.id) {
-    return assistant.respond('Missing required parameter: id', { code: 400 });
-  }
-
-  const uid = user.auth.uid;
-  const formRef = admin.firestore().doc(`forms/${settings.id}`);
-  const doc = await formRef.get();
-
-  if (!doc.exists) {
-    return assistant.respond('Form not found', { code: 404 });
-  }
-
-  // Ownership check
-  if (doc.data().owner !== uid) {
-    return assistant.respond('Not authorized to edit this form', { code: 403 });
-  }
-
-  const now = new Date().toISOString();
-  const nowUnix = Date.now();
-
-  const updates = {
-    name: settings.name,
-    description: settings.description,
-    settings: settings.settings,
-    pages: settings.pages,
-    edited: {
-      timestamp: now,
-      timestampUNIX: nowUnix,
-    },
-    metadata: Manager.Metadata().set({ tag: 'forms/put' }),
-  };
-
-  await formRef.update(updates);
-
-  assistant.log(`Updated form ${settings.id} for user ${uid}`);
-
-  analytics.event('forms', { action: 'update' });
-
-  return assistant.respond({ data: { id: settings.id } });
-};

package/src/manager/schemas/forms/delete.js

@@ -1,6 +0,0 @@
-/**
- * Schema for DELETE /forms
- */
-module.exports = () => ({
-  id: { types: ['string'], default: undefined, required: true },
-});

package/src/manager/schemas/forms/get.js

@@ -1,6 +0,0 @@
-/**
- * Schema for GET /forms
- */
-module.exports = () => ({
-  id: { types: ['string'], default: undefined },
-});