@uides/stepwise 1.1.0-d0adc9fb → 2.0.0-07ee8440

package/src/schemas/step.ts

@@ -1,40 +1,40 @@
 import * as v from 'valibot';
 import { ActionsSchema } from '@uides/stepwise/schemas/action';
 import {
-  ComponentLayout,
+  ComponentLayoutSchema,
+  DisplayModeSchema,
+  DisplayLangSchema,
+  validateField,
   DisplayMode,
   DisplayLang,
-  nullish,
-  object,
-  validateField,
 } from '@uides/stepwise/schemas/common';
 import { FieldsSchema } from '@uides/stepwise/schemas/field';
 import { FieldsetsSchema } from '@uides/stepwise/schemas/fieldset';
 
-const ManifestAttachment = object({
+const ManifestAttachmentSchema = v.strictObject({
   field_name: v.string(),
-  retrieval_scope: nullish(v.string()),
+  retrieval_scope: v.nullish(v.string()),
   'manifest-position': v.picklist(['no', 'begin', 'end']),
-  'attachment-handler': nullish(v.string()),
+  'attachment-handler': v.nullish(v.string()),
 });
 
 /**
  * Describes what to display in a step.
  */
-export const StepDisplayContentSchema = object({
-  title: nullish(v.string()),
-  captionLeft: nullish(v.string()),
+export const StepDisplayContentSchema = v.strictObject({
+  title: v.nullish(v.string()),
+  captionLeft: v.nullish(v.string()),
   /**
    * The name of the service that the step belongs to
    *
    * It is used to display the name of the service that owns the template this step belongs to,
    * in the header of the UI.
    */
-  serviceName: nullish(v.string()),
+  serviceName: v.nullish(v.string()),
   /**
    * The URL of the service to redirect to when the user clicks on the service name
    */
-  serviceURL: nullish(v.string()),
+  serviceURL: v.nullish(v.string()),
   /**
    * Service logo to display in the header
    *
@@ -42,44 +42,44 @@ export const StepDisplayContentSchema = object({
    * for the template that the step belongs to. It is used to display the logo in the
    * header of the UI.
    */
-  serviceLogo: nullish(v.string()),
+  serviceLogo: v.nullish(v.string()),
   /**
    * The URL of the service to redirect to when the user clicks on the service logo
    */
-  serviceLogoURL: nullish(v.string()),
-  footerContent: nullish(v.string()),
-  footerLogo: nullish(v.string()),
-  footerTop: nullish(v.boolean()),
-  termsTitle: nullish(v.string()),
-  termsURL: nullish(v.string()),
-  fontName: nullish(v.string()),
-  'page-numbering': nullish(v.boolean()),
-  'signature-position': nullish(v.array(v.number())),
-  'signature-page': nullish(v.picklist(['first', 'last'])),
-  'state-label': nullish(
+  serviceLogoURL: v.nullish(v.string()),
+  footerContent: v.nullish(v.string()),
+  footerLogo: v.nullish(v.string()),
+  footerTop: v.nullish(v.boolean()),
+  termsTitle: v.nullish(v.string()),
+  termsURL: v.nullish(v.string()),
+  fontName: v.nullish(v.string()),
+  'page-numbering': v.nullish(v.boolean()),
+  'signature-position': v.nullish(v.array(v.number())),
+  'signature-page': v.nullish(v.picklist(['first', 'last'])),
+  'state-label': v.nullish(
     v.record(v.picklist(['editing', 'issued']), v.string())
   ),
-  'sidebar-state-label': nullish(v.string()),
-  'sidebar-refcode-label': nullish(v.string()),
-  'sidebar-template-label': nullish(v.string()),
-  'sidebar-issuedate-label': nullish(v.string()),
-  'success-message': nullish(v.string()),
-  'success-code-message': nullish(v.string()),
-  'as-manifest-for-attachment': nullish(ManifestAttachment),
-  layout: nullish(ComponentLayout),
+  'sidebar-state-label': v.nullish(v.string()),
+  'sidebar-refcode-label': v.nullish(v.string()),
+  'sidebar-template-label': v.nullish(v.string()),
+  'sidebar-issuedate-label': v.nullish(v.string()),
+  'success-message': v.nullish(v.string()),
+  'success-code-message': v.nullish(v.string()),
+  'as-manifest-for-attachment': v.nullish(ManifestAttachmentSchema),
+  layout: v.nullish(ComponentLayoutSchema),
 });
-type StepDisplay = v.Output<typeof StepDisplayContentSchema>;
+type StepDisplay = v.InferOutput<typeof StepDisplayContentSchema>;
 type StepDisplayType = Partial<
   Record<DisplayMode, Partial<Record<DisplayLang, StepDisplay>>>
 >;
 
 const StepDisplaySchema = v.record(
-  DisplayMode,
-  v.record(DisplayLang, StepDisplayContentSchema)
-) as unknown as v.BaseSchema<StepDisplayType, StepDisplayType>;
+  DisplayModeSchema,
+  v.record(DisplayLangSchema, StepDisplayContentSchema)
+) as unknown as v.GenericSchema<StepDisplayType, StepDisplayType>;
 
-const PossibleNextStepsSchema = object({
-  documentation: object({
+const PossibleNextStepsSchema = v.strictObject({
+  documentation: v.strictObject({
     label: v.string(),
   }),
 });
@@ -87,90 +87,91 @@ const PossibleNextStepsSchema = object({
 /**
  * Describes a step.
  */
-export const StepSchema = object(
-  {
+export const StepSchema = v.pipe(
+  v.strictObject({
     /**
      * Actions that can be performed on the step
      *
      * An action is usually translated as a button in the UI, which the user can click
      * to perform an action, like downloading a PDF or going to the next step.
      */
-    actions: nullish(ActionsSchema), // TODO: Not optional in backend schema but optional in some templates
+    actions: v.nullish(ActionsSchema), // TODO: Not optional in backend schema but optional in some templates
     'action-order': v.string(),
-    fields: nullish(FieldsSchema), // TODO: Not optional in backend schema but optional in some templates
-    fieldsets: nullish(FieldsetsSchema), // TODO: Not optional in backend schema but optional in some templates
+    fields: v.nullish(FieldsSchema), // TODO: Not optional in backend schema but optional in some templates
+    fieldsets: v.nullish(FieldsetsSchema), // TODO: Not optional in backend schema but optional in some templates
     'fieldset-order': v.string(),
-    possible_next_steps: nullish(v.record(PossibleNextStepsSchema)),
-    'field-compute-order': nullish(v.string()),
-    next_step: nullish(v.string()),
-    pre_access_hook: nullish(v.string()),
-    decide_next_step: nullish(v.string()),
+    possible_next_steps: v.nullish(
+      v.record(v.string(), PossibleNextStepsSchema)
+    ),
+    'field-compute-order': v.nullish(v.string()),
+    next_step: v.nullish(v.string()),
+    pre_access_hook: v.nullish(v.string()),
+    decide_next_step: v.nullish(v.string()),
     display: StepDisplaySchema,
-    validator: nullish(v.string()),
+    validator: v.nullish(v.string()),
     /** @default false */
-    'is-final-view': nullish(v.boolean()),
-    validation_dynamic_info: nullish(v.string()),
-    'has-display-fields': nullish(v.boolean()),
-    targets: nullish(v.array(v.record(v.any()))),
-  },
-  [
-    validateField('fieldsets', (fieldsets, step) => {
-      if (!fieldsets || !step.fields) return true;
-      const fieldsSpec = step.fields;
-      for (const fieldset of Object.values(fieldsets)) {
-        if (!validateOrderOnSet(fieldset['field-order'], fieldsSpec))
-          return false;
-      }
-      return true;
-    }),
-    validateField('fieldset-order', (fieldsetOrder, step) => {
-      if (!fieldsetOrder || !step.fieldsets) return true;
-      return validateOrderOnSet(fieldsetOrder, step.fieldsets);
-    }),
-    validateField('action-order', (actionOrder, step) => {
-      if (!actionOrder || !step.actions) return true;
-      return validateOrderOnSet(actionOrder, step.actions);
-    }),
-    validateField('decide_next_step', (decideNextStep, step) => {
-      if (!decideNextStep) return true;
-      const possibleNextSteps = Object.keys(step.possible_next_steps || {});
-      if (!possibleNextSteps.length) return false;
-      return true;
-    }),
-    validateField('fields', (fields, step) => {
-      const actions = step.actions;
-      const actionOrder = step['action-order'];
-      if (!actionOrder.split(' ').includes('update')) return true;
-      if (
-        actions &&
-        actions['update'] &&
-        'component-params' in actions['update'] &&
-        actions['update']['component-params'] &&
-        'ensure-no-input' in actions['update']['component-params'] &&
-        actions['update']['component-params']['ensure-no-input']
-      ) {
-        for (const field of Object.values(fields || {})) {
-          if (
-            field['user-input-mode'] !== 'noinput' &&
-            field['user-input-mode'] !== 'display'
-          )
-            return false;
-        }
-      }
-      return true;
-    }),
-    validateField('fields', (fields) => {
+    'is-final-view': v.nullish(v.boolean()),
+    validation_dynamic_info: v.nullish(v.string()),
+    'has-display-fields': v.nullish(v.boolean()),
+    targets: v.nullish(v.array(v.record(v.string(), v.any()))),
+  }),
+
+  validateField('fieldsets', (fieldsets, step) => {
+    if (!fieldsets || !step.fields) return true;
+    const fieldsSpec = step.fields;
+    for (const fieldset of Object.values(fieldsets)) {
+      if (!validateOrderOnSet(fieldset['field-order'], fieldsSpec))
+        return false;
+    }
+    return true;
+  }),
+  validateField('fieldset-order', (fieldsetOrder, step) => {
+    if (!fieldsetOrder || !step.fieldsets) return true;
+    return validateOrderOnSet(fieldsetOrder, step.fieldsets);
+  }),
+  validateField('action-order', (actionOrder, step) => {
+    if (!actionOrder || !step.actions) return true;
+    return validateOrderOnSet(actionOrder, step.actions);
+  }),
+  validateField('decide_next_step', (decideNextStep, step) => {
+    if (!decideNextStep) return true;
+    const possibleNextSteps = Object.keys(step.possible_next_steps || {});
+    if (!possibleNextSteps.length) return false;
+    return true;
+  }),
+  validateField('fields', (fields, step) => {
+    const actions = step.actions;
+    const actionOrder = step['action-order'];
+    if (!actionOrder.split(' ').includes('update')) return true;
+    if (
+      actions &&
+      actions['update'] &&
+      'component-params' in actions['update'] &&
+      actions['update']['component-params'] &&
+      'ensure-no-input' in actions['update']['component-params'] &&
+      actions['update']['component-params']['ensure-no-input']
+    ) {
       for (const field of Object.values(fields || {})) {
         if (
-          (field['user-input-mode'] === 'required' ||
-            field['user-input-mode'] === 'optional') &&
-          !field.display
+          field['user-input-mode'] !== 'noinput' &&
+          field['user-input-mode'] !== 'display'
         )
           return false;
       }
-      return true;
-    }),
-  ]
+    }
+    return true;
+  }),
+  validateField('fields', (fields) => {
+    for (const field of Object.values(fields || {})) {
+      if (
+        (field['user-input-mode'] === 'required' ||
+          field['user-input-mode'] === 'optional') &&
+        !field.display
+      )
+        return false;
+    }
+    return true;
+  })
 );
 
 function validateOrderOnSet(
@@ -185,20 +186,20 @@ function validateOrderOnSet(
   return true;
 }
 
-export type Step = v.Output<typeof StepSchema>;
-type StepSchema = v.BaseSchema<Step, Step>;
+export type Step = v.InferOutput<typeof StepSchema>;
+type StepSchemaType = v.GenericSchema<Step, Step>;
 
 export type StepsType = Record<string, Step>;
-const StepsSchema = v.record(v.string(), StepSchema) as v.BaseSchema<
+const StepsSchema = v.record(v.string(), StepSchema) as v.GenericSchema<
   StepsType,
   StepsType
 >;
 export const StepsSpecSchema = v.object({
   'steps-order': v.string(),
-  collectable: nullish(v.boolean()),
-  sign: nullish(v.boolean()),
+  collectable: v.nullish(v.boolean()),
+  sign: v.nullish(v.boolean()),
   steps: StepsSchema,
-  'intro-step': nullish(StepSchema as unknown as StepSchema),
+  'intro-step': v.nullish(StepSchema as unknown as StepSchemaType),
 });
-export type StepsSpec = v.Output<typeof StepsSpecSchema>;
-export type StepsSpecSchema = v.BaseSchema<StepsSpec, StepsSpec>;
+export type StepsSpec = v.InferOutput<typeof StepsSpecSchema>;
+export type StepsSpecSchemaType = v.GenericSchema<StepsSpec, StepsSpec>;

package/src/schemas/template/enums.ts

@@ -10,7 +10,7 @@ import * as v from 'valibot';
  * @value 'global' Global recipient.
  * @value 'dataset' Dataset recipient.
  */
-export const RecipientPolicy = v.picklist([
+export const RecipientPolicySchema = v.picklist([
   'none',
   'owner_box',
   'owner',
@@ -19,4 +19,4 @@ export const RecipientPolicy = v.picklist([
   'dataset',
   'targets', // TODO: Add documentation for this value
 ]);
-export type RecipientPolicy = v.Output<typeof RecipientPolicy>;
+export type RecipientPolicy = v.InferOutput<typeof RecipientPolicySchema>;

package/src/schemas/template/template-base.ts

@@ -1,7 +1,9 @@
 import * as v from 'valibot';
-import { nullish, object } from '@uides/stepwise/schemas/common';
-import { StepsSpecSchema } from '@uides/stepwise/schemas/step';
-import { RecipientPolicy } from '@uides/stepwise/schemas/template/enums';
+import {
+  StepsSpecSchema,
+  StepsSpecSchemaType,
+} from '@uides/stepwise/schemas/step';
+import { RecipientPolicySchema } from '@uides/stepwise/schemas/template/enums';
 
 /**
  * Describes a template
@@ -9,21 +11,21 @@ import { RecipientPolicy } from '@uides/stepwise/schemas/template/enums';
  * A template is a set of steps that the user must complete in order to complete a process
  * in the system, whether that is the issuance of a document or the entry of a request.
  */
-export const TemplateBase = object({
+export const TemplateBaseSchema = v.strictObject({
   /**
    * Template's creation date
    */
-  created_at: nullish(v.string()),
+  created_at: v.nullish(v.string()),
   /** Brief summary of template */
   description: v.string(),
-  id: nullish(v.number()),
+  id: v.nullish(v.number()),
   /**
    * Defines the fields that are used to index documents
    *
    * A list of fields of the document, that are used to index multiple documents upon their
    * presentation to the user's gate interface.
    */
-  index_by_fields: nullish(v.string()),
+  index_by_fields: v.nullish(v.string()),
   /**
    * Whether the template is officially published or not.
    *
@@ -31,7 +33,7 @@ export const TemplateBase = object({
    * Otherwise it is considered a draft and the documents it produces are not valid.
    * @default true
    */
-  is_official: nullish(v.boolean()),
+  is_official: v.nullish(v.boolean()),
   /**
    * Codename of the gate that owns the template
    *
@@ -43,15 +45,15 @@ export const TemplateBase = object({
    * Recipient's business title
    * @deprecated
    */
-  recipient_hint: nullish(v.string()),
+  recipient_hint: v.nullish(v.string()),
   /** How the document's recipient is determined */
-  recipient_policy: RecipientPolicy,
+  recipient_policy: RecipientPolicySchema,
   /** The template's unique identifier */
   refname: v.string(),
   /**
    * List of templates with which replies to the document can be issued.
    */
-  reply_templates: nullish(v.array(v.string())),
+  reply_templates: v.nullish(v.array(v.string())),
   /** Brief title of template */
   shortname: v.string(),
   /** Description of template */
@@ -59,9 +61,9 @@ export const TemplateBase = object({
   /**
    * Specification of the steps of the template.
    */
-  steps_spec: nullish(StepsSpecSchema as unknown as StepsSpecSchema),
+  steps_spec: v.nullish(StepsSpecSchema as unknown as StepsSpecSchemaType),
 });
 
-export type TemplateBase = v.Output<typeof TemplateBase>;
+export type TemplateBase = v.InferOutput<typeof TemplateBaseSchema>;
 
 export default TemplateBase;

package/src/schemas/template/template-source.ts

@@ -1,6 +1,5 @@
 import * as v from 'valibot';
-import { nullish, object } from '@uides/stepwise/schemas/common';
-import { TemplateBase } from '@uides/stepwise/schemas/template/template-base';
+import { TemplateBaseSchema } from '@uides/stepwise/schemas/template/template-base';
 
 /**
  * Template model used in the backend.
@@ -10,36 +9,36 @@ import { TemplateBase } from '@uides/stepwise/schemas/template/template-base';
  *
  * @see {@link TemplateBase} for the definition of a template.
  */
-export const TemplateSource = object(
+export const TemplateSourceSchema = v.strictObject(
   {
-    ...TemplateBase.entries,
+    ...TemplateBaseSchema.entries,
     /**
      * Action to execute when the document is issued.
      */
-    action_on_issue: nullish(v.string()),
-    case_prefixes: nullish(v.array(v.string())),
+    action_on_issue: v.nullish(v.string()),
+    case_prefixes: v.nullish(v.array(v.string())),
     /**
      * Claims that are not checked for in the user's session
      */
-    exempted_claims: nullish(v.array(v.string())),
+    exempted_claims: v.nullish(v.array(v.string())),
     /**
      * Extra claims to check for in the user's session.
      *
      * When creating a new declaration that includes the template, the application checks
      * that the session contains all the claims specified in this field.
      */
-    extra_required_claims: nullish(v.array(v.string())),
-    posting_whitelist: nullish(v.array(v.string())),
+    extra_required_claims: v.nullish(v.array(v.string())),
+    posting_whitelist: v.nullish(v.array(v.string())),
     /**
      *  Whether a case number is assigned on instantiation of the template.
      *  @default false
      */
-    requires_case: nullish(v.boolean()),
-    validation_context: nullish(v.string()),
+    requires_case: v.nullish(v.boolean()),
+    validation_context: v.nullish(v.string()),
     /**
      * Defines the access policy of th document in the validation phase
      */
-    validation_policy: nullish(v.string()),
+    validation_policy: v.nullish(v.string()),
   }
   // TODO: Is this validation pipeline necessary?
   // [
@@ -84,6 +83,6 @@ export const TemplateSource = object(
 //   return true;
 // }
 
-export type TemplateSource = v.Output<typeof TemplateSource>;
+export type TemplateSource = v.InferOutput<typeof TemplateSourceSchema>;
 
 export default TemplateSource;

package/src/schemas/template/template.ts

@@ -1,6 +1,5 @@
 import * as v from 'valibot';
-import { nullish, object } from '@uides/stepwise/schemas/common';
-import { TemplateBase } from '@uides/stepwise/schemas/template/template-base';
+import { TemplateBaseSchema } from '@uides/stepwise/schemas/template/template-base';
 
 /**
  * Template type used in the frontend.
@@ -10,13 +9,13 @@ import { TemplateBase } from '@uides/stepwise/schemas/template/template-base';
  *
  * @see {@link TemplateBase} for the definition of a template.
  */
-export const Template = object({
-  ...TemplateBase.entries,
+export const TemplateSchema = v.strictObject({
+  ...TemplateBaseSchema.entries,
   /**
    * Whether the template is enabled or not.
    */
-  enabled: nullish(v.boolean()),
-  template_type: object({
+  enabled: v.nullish(v.boolean()),
+  template_type: v.strictObject({
     /** @default 'application' */
     refname: v.string(),
     /** @default [] */
@@ -27,7 +26,7 @@ export const Template = object({
    * Recipient's business title
    * @deprecated
    */
-  recipient_hint: nullish(v.string()),
+  recipient_hint: v.nullish(v.string()),
   /**
    * Claims that the application checks for in the user's session.
    *
@@ -40,12 +39,12 @@ export const Template = object({
    * An entity's gate can be the owner of a template. If not specified, the template is considered
    * to be owned by the "System".
    */
-  owner: nullish(v.string()),
-  login_endpoint: nullish(v.string()),
-  fields: nullish(v.array(v.any())),
-  allow_custom_recipient: nullish(v.boolean()),
-  listable: nullish(v.boolean()),
+  owner: v.nullish(v.string()),
+  login_endpoint: v.nullish(v.string()),
+  fields: v.nullish(v.array(v.any())),
+  allow_custom_recipient: v.nullish(v.boolean()),
+  listable: v.nullish(v.boolean()),
 });
-export type Template = v.Output<typeof Template>;
+export type Template = v.InferOutput<typeof TemplateSchema>;
 
 export default Template;

package/src/schemas/validation-context/enums.ts

@@ -7,13 +7,13 @@ import * as v from 'valibot';
  * @value 'validate-document-qrcode' Validate document QR code.
  * @value 'paragraph' Paragraph.
  */
-export const ValidationFieldComponent = v.picklist([
+export const ValidationFieldComponentSchema = v.picklist([
   'validate-document-string',
   'validate-document-qrcode',
   'paragraph',
 ]);
-export type ValidationFieldComponent = v.Output<
-  typeof ValidationFieldComponent
+export type ValidationFieldComponent = v.InferOutput<
+  typeof ValidationFieldComponentSchema
 >;
 
 /**
@@ -24,10 +24,10 @@ export type ValidationFieldComponent = v.Output<
  * @value 'noinput' No user input allowed, like 'display'.
  * @value 'display' Display only the value of the field, like 'noinput'.
  */
-export const UserInputMode = v.picklist([
+export const UserInputModeSchema = v.picklist([
   'required',
   'optional',
   'noinput',
   'display',
 ]);
-export type UserInputMode = v.Output<typeof UserInputMode>;
+export type UserInputMode = v.InferOutput<typeof UserInputModeSchema>;