title: SyntaxError: Unexpected end of JSON input when a fuction added
body: <p>I am wroking on a next js application with postgres. I am encountering an error</p>
  <pre><code>SyntaxError: Unexpected end of JSON input
      at JSON.parse (&lt;anonymous&gt;)
      at /home/sahood/Desktop/final-invoice-1/node_modules/@prisma/client/runtime/index.js:28174:31
      at processTicksAndRejections (node:internal/process/task_queues:96:5)
  </code></pre>
  <p>I found that the error is occured from this page</p>
  <pre><code>import { Injectable } from '@nestjs/common';
  import { PrismaService } from '../../shared/services/prisma.service';
  import * as fs from 'fs';
  import * as path from 'path';
  import { Template } from '@prisma/client';
  import * as get from 'lodash/get';
  import * as isEmpty from 'lodash/isEmpty';
  
  const TEMPLATES_DIR = '/templates/';
  const TEMPLATES_BASE = path.join(process.cwd(), TEMPLATES_DIR);
  
  // getDirectories function
  function getDirectories(srcpath) {
    return fs
      .readdirSync(srcpath)
      .map((file) =&gt; path.join(srcpath, file))
      .filter((path) =&gt; fs.statSync(path).isDirectory());
  }
  
  // getFiles function
  function getFiles(srcpath) {
    return fs
      .readdirSync(srcpath)
      .map((file) =&gt; path.join(srcpath, file))
      .filter((path) =&gt; fs.statSync(path).isFile())
      .map((file) =&gt; file.replace(/\.[^/.]+$/, ''));
  }
  
  @Injectable()
  export class TemplateService {
    constructor(public readonly prisma: PrismaService) {}
  
    async onModuleInit() {
      await this._initializeMeta();
      await this.getTemplateTypes();
    }
  
    async initializeDefaults(shopName: string) {
      const templateTypes = await this.getTemplateTypes();
      await Promise.all(
        templateTypes.map(async (type) =&gt; {
          const handle = type.handle;
          const defaultSlug = type.meta.default;
          await this.initializeTemplateConfig(shopName, handle, defaultSlug);
          await this.changeSelectedTemplate(shopName, handle, defaultSlug);
        }),
      );
    }
  
    getTemplatesByType(type: string) {
      return this.prisma.template.findMany({
        where: {
          type,
        },
      });
    }
  
    getTemplateByTypeAndSlug(type: string, slug: string) {
      return this.prisma.template.findUnique({
        where: {
          slug_type: { type, slug },
        },
      });
    }
  
    async getSelectedTemplate(shopName: string, type: string): Promise&lt;Template&gt; {
      const selectedTemplate = await this.prisma.shop.findUnique({
        where: {
          name: shopName,
        },
        include: {
          shopTemplate: {
            where: {
              templateType: type,
            },
            include: {
              template: true,
            },
          },
        },
      });
      return get(selectedTemplate, 'shopTemplate[0].template', null);
    }
  
    async changeSelectedTemplate(
      shopName: string,
      type: string,
      slug: string,
    ): Promise&lt;Template&gt; {
      const shop = await this.prisma.shop.findUnique({
        where: {
          name: shopName,
        },
        include: {
          shopTemplate: true,
        },
      });
      const shopTemplate = await this.prisma.shopTemplate.upsert({
        where: {
          shopId_templateType: {
            shopId: shop.id,
            templateType: type,
          },
        },
        include: {
          template: true,
        },
        create: {
          shopId: shop.id,
          templateType: type,
          templateSlug: slug,
        },
        update: {
          templateSlug: slug,
        },
      });
  
      return get(shopTemplate, 'template', null);
    }
  
    async getTemplateTypes() {
      const dirs = getDirectories(TEMPLATES_BASE);
  
      const types = await Promise.all(
        dirs.map(async (typePath) =&gt; {
          const metaPath = path.join(typePath, 'meta.js');
          const meta = await import(metaPath);
          return {
            handle: path.basename(typePath),
            meta,
          };
        }),
      );
      return types;
    }
  
    async getMetaOfType(type: string) {
      const templatePath = path.join(TEMPLATES_BASE, type);
      const metaPath = path.join(templatePath, 'meta.js');
      const meta = await import(metaPath);
      return {
        handle: type,
        meta,
      };
    }
  
    async getTemplateConfig(shopName: string, type: string, slug: string) {
      const { meta } = await this.getMetaOfType(type);
      const templateConfig = await this.prisma.shop.findUnique({
        where: {
          name: shopName,
        },
        include: {
          shopTemplateConfig: {
            where: {
              templateType: type,
              templateSlug: slug,
            },
          },
        },
      });
  
      // adding meta.js panel handles if it is new and does not exist in the db data
      for (const panel of meta.panels) {
        if (templateConfig.shopTemplateConfig[0]?.config[panel.handle]) continue;
        try {
          templateConfig.shopTemplateConfig[0].config[panel.handle] = panel.state;
        } catch (error) {
          // console.log(error);
        }
      }
  
      return get(templateConfig, 'shopTemplateConfig[0]', null);
    }
  
    async setTemplateConfig(
      shopName: string,
      type: string,
      slug: string,
      config,
    ): Promise&lt;Template&gt; {
      const shop = await this.prisma.shop.findUnique({
        where: {
          name: shopName,
        },
        include: {
          shopTemplateConfig: true,
        },
      });
      const shopTemplate = await this.prisma.shopTemplateConfig.upsert({
        where: {
          shopId_templateType_templateSlug: {
            shopId: shop.id,
            templateType: type,
            templateSlug: slug,
          },
        },
        include: {
          template: true,
        },
        create: {
          shopId: shop.id,
          templateType: type,
          templateSlug: slug,
          config: config,
        },
        update: {
          config: config,
        },
      });
  
      return get(shopTemplate, 'template', null);
    }
  
    async initializeTemplateConfig(shopName: string, type: string, slug: string) {
      const { meta } = await this.getMetaOfType(type);
  
      const initialConfig = {};
  
      for (const panel of meta.panels) {
        initialConfig[panel.handle] = panel.state;
      }
  
      await this.setTemplateConfig(shopName, type, slug, initialConfig);
  
      return initialConfig;
    }
  
    _getTemplatePath(type: string, fileName: string) {
      return path.join(TEMPLATES_BASE, type, 'styles', fileName);
    }
  
    _getLiquidPath(type: string) {
      return path.join(TEMPLATES_BASE, type, 'index.liquid');
    }
  
    async _getTemplateMeta(type: string, slug: string) {
      try {
        const meta = this._getTemplatePath(type, `${slug}.js`);
        const data = await import(meta);
        return data;
      } catch (error) {
        return {};
      }
    }
  
    async _initializeMeta() {
      for (const templateTypePath of getDirectories(TEMPLATES_BASE)) {
        const type = path.basename(templateTypePath);
  
        const basePath = path.join(TEMPLATES_BASE, type, 'styles');
        if (!fs.existsSync(basePath)) {
          continue;
        }
        console.log(getFiles(basePath))
  
        // where I applied getFiles function
        for (const templatePath of getFiles(basePath)) {
          
          const templateSlug = path.basename(templatePath);
  console.log(templateSlug)
          const meta = await this._getTemplateMeta(type, templateSlug);
          if (isEmpty(meta)) {
            console.warn(`✘ ${type}/${templateSlug} : meta.js not found`);
            continue;
          }
          console.log(`✔ ${type}/${templateSlug} : meta initialized`);
          console.log(meta)
          await this.prisma.template.upsert({
            where: {
              slug_type: { type, slug: templateSlug },
            },
            update: {
              ...meta,
            },
            create: {
              type,
              slug: templateSlug,
              ...meta,
            },
          });
          console.log(meta)
        }
      }
    }
  }
  </code></pre>
  <p>The error is happening when I replace <em><strong>getDirectories</strong></em> fuction with <em><strong>getFiles</strong></em> in only one place, to ensure update the data every time the change occurred in parameter data</p>
  <p><strong>And that error is only shown on my device, except it works fine on my college devices.</strong></p>
  <p>I have tried to delete node modules, .next folder and dist folder.I restarted the device,  i cloned again and none of it worked.</p>