sdk/effect/parsers

Classes

SDKCore_Parsers

Defined in: studiocms/packages/studiocms/src/sdk/effect/parsers.ts:24^

Extends

• any

Constructors

Constructor

new SDKCore_Parsers(): SDKCore_Parsers

Returns

SDKCore_Parsers

Inherited from

Effect.Service<SDKCore_Parsers>()(
  'studiocms/sdk/SDKCore_Parsers',
  {
    effect: Effect.gen(function () {
      /
        Parses an unknown input and casts it to an array of numbers.

        @param ids - The input to be parsed, expected to be an array of numbers.
        @returns An array of numbers.
       /
      const parseIdNumberArray = (ids: unknown): Effect.Effect<number[], SDKCoreError, never> =>
        Effect.try({
          try: () => {
            if (!Array.isArray(ids) || !ids.every((n) => typeof n === 'number'))
              throw new Error('Expected an array of numbers');
            return ids as number[];
          },
          catch: (error) =>
            new SDKCoreError({
              type: 'UNKNOWN',
              cause: new StudioCMS_SDK_Error(parseIdNumberArray Error: ${error}),
            }),
        });

      /
        Parses the given input as an array of strings.

        @param ids - The input to be parsed, expected to be an array of unknown type.
        @returns An array of strings parsed from the input.
       /
      const parseIdStringArray = (ids: unknown): Effect.Effect<string[], SDKCoreError, never> =>
        Effect.try({
          try: () => {
            if (!Array.isArray(ids) || !ids.every((n) => typeof n === 'string'))
              throw new Error('Expected an array of strings');
            return ids as string[];
          },
          catch: (error) =>
            new SDKCoreError({
              type: 'UNKNOWN',
              cause: new StudioCMS_SDK_Error(parseIdStringArray Error: ${error}),
            }),
        });

      /
        Fixes the diff items by parsing the pageMetaData field.
        @param items - The diff items to be fixed, can be a single item or an array.
       /
      const fixDiff = <T extends diffItem | diffItem[]>(
        items: T
      ): Effect.Effect<DiffReturnType<T>, SDKCoreError, never> =>
        Effect.try({
          try: () => {
            if (Array.isArray(items)) {
              const toReturn: diffReturn[] = [];
              for (const { pageMetaData, ...rest } of items) {
                toReturn.push({
                  ...rest,
                  pageMetaData: jsonParse<{
                    start: Partial<tsPageDataSelect>;
                    end: Partial<tsPageDataSelect>;
                  }>(pageMetaData as string),
                });
              }
              return toReturn as DiffReturnType<T>;
            }

            return {
              ...items,
              pageMetaData: jsonParse<{
                start: Partial<tsPageDataSelect>;
                end: Partial<tsPageDataSelect>;
              }>(items.pageMetaData as string),
            } as DiffReturnType<T>;
          },
          catch: (error) =>
            new SDKCoreError({
              type: 'UNKNOWN',
              cause: new StudioCMS_SDK_Error(fixDiff Error: ${error}),
            }),
        });

      return {
        parseIdNumberArray,
        parseIdStringArray,
        fixDiff,
      };
    }),
  }
).constructor