@teleporthq/teleport-plugin-next-static-paths 0.44.0-alpha.0 → 0.44.1

package/__tests__/data-source-state-skip-static-paths.test.ts

@@ -0,0 +1,52 @@
+import { ComponentStructure } from '@teleporthq/teleport-types'
+import { createStaticPathsPlugin } from '../src/index'
+
+// A page that seeds a state from a data source renders per request (its
+// getStaticProps is turned into getServerSideProps at the end of the page
+// pipeline), and Next.js refuses getStaticPaths beside getServerSideProps. The
+// plugin must therefore stay out of such a dynamic page — and only of such a
+// page: a state resolved in the browser keeps the page statically generated.
+
+const DS_ID = 'ds-1'
+
+const makeStructure = (query: string): ComponentStructure =>
+  ({
+    uidl: {
+      name: 'Profile',
+      node: { type: 'element', content: { elementType: 'container' } },
+      stateDefinitions: {
+        rows: {
+          type: 'array',
+          defaultValue: [],
+          dataSourceBinding: { dataSourceId: DS_ID, refPath: ['profiles'] },
+          query,
+        },
+      },
+      outputOptions: { folderPath: ['profile'], fileName: '[id]' },
+    },
+    chunks: [{ name: 'jsx-component' }],
+    dependencies: {},
+    options: {
+      dataSources: { [DS_ID]: { id: DS_ID, type: 'teleport', config: {} } },
+      resources: { items: {}, path: ['utils', 'data-sources'] },
+    },
+  } as unknown as ComponentStructure)
+
+describe('teleport-plugin-next-static-paths: data-source state skip', () => {
+  const plugin = createStaticPathsPlugin()
+
+  it('emits no getStaticPaths for a dynamic page that seeds a state from a data source', async () => {
+    const result = await plugin(makeStructure('SELECT * FROM profiles LIMIT 5'))
+
+    expect(result.chunks.find((chunk) => chunk.name === 'getStaticPaths')).toBeUndefined()
+    expect(result.chunks.find((chunk) => chunk.name === 'getStaticProps')).toBeUndefined()
+  })
+
+  it('still emits the fallback getStaticPaths when the state is only resolved in the browser', async () => {
+    const result = await plugin(
+      makeStructure("SELECT * FROM profiles WHERE user_id = '{{Current User.id}}'")
+    )
+
+    expect(result.chunks.find((chunk) => chunk.name === 'getStaticPaths')).toBeDefined()
+  })
+})

package/__tests__/page-folder-name-collision.test.ts

@@ -0,0 +1,75 @@
+import { ComponentStructure } from '@teleporthq/teleport-types'
+import { createStaticPathsPlugin } from '../src/index'
+
+/**
+ * Regression guard for the `pages/resources/[id].js` build break — the
+ * getStaticPaths half of it:
+ *
+ *   Module not found: Can't resolve '../fetch_content_items_paths'
+ *
+ * See the sibling test in teleport-plugin-next-static-props for the full story.
+ */
+
+const RESOURCE_ID = 'fetch-content-item-paths'
+const RESOURCE_NAME = 'fetch_content_items_paths'
+
+const makeStructure = (params: {
+  folderPath: string[]
+  resourcesPath?: string[]
+  pagesPath?: string[]
+}): ComponentStructure => {
+  const { folderPath, resourcesPath = ['resources'], pagesPath } = params
+  return {
+    uidl: {
+      name: 'CustomResources',
+      node: { type: 'element', content: { elementType: 'container' } },
+      outputOptions: {
+        folderPath,
+        fileName: '[id]',
+        initialPathsData: {
+          exposeAs: { name: 'id', valuePath: [], itemValuePath: ['id'] },
+          resource: { id: RESOURCE_ID, params: {} },
+        },
+      },
+    },
+    chunks: [{ name: 'jsx-component' }],
+    dependencies: {},
+    options: {
+      ...(pagesPath && { pagesPath }),
+      resources: {
+        items: { [RESOURCE_ID]: { id: RESOURCE_ID, name: RESOURCE_NAME } },
+        path: resourcesPath,
+      },
+    },
+  } as unknown as ComponentStructure
+}
+
+describe('teleport-plugin-next-static-paths: resource import path', () => {
+  const plugin = createStaticPathsPlugin()
+
+  it('reaches the project resources folder from a page whose folder is named "resources"', async () => {
+    const structure = await plugin(makeStructure({ folderPath: ['resources'] }))
+
+    expect(structure.dependencies.fetchContentItemsPathsResource.path).toBe(
+      `../../resources/${RESOURCE_NAME}`
+    )
+  })
+
+  it('keeps working for a page in a non-colliding subfolder', async () => {
+    const structure = await plugin(makeStructure({ folderPath: ['blog'] }))
+
+    expect(structure.dependencies.fetchContentItemsPathsResource.path).toBe(
+      `../../resources/${RESOURCE_NAME}`
+    )
+  })
+
+  it('honours a pages root that is not the project root child', async () => {
+    const structure = await plugin(
+      makeStructure({ folderPath: ['resources'], pagesPath: ['src', 'pages'] })
+    )
+
+    expect(structure.dependencies.fetchContentItemsPathsResource.path).toBe(
+      `../../../resources/${RESOURCE_NAME}`
+    )
+  })
+})

package/__tests__/same-table-mutation-skip-static-paths.test.ts

@@ -0,0 +1,158 @@
+import { ComponentStructure, UIDLWorkflows } from '@teleporthq/teleport-types'
+import { createStaticPathsPlugin } from '../src/index'
+
+// Regression guard: a page that reads one specific row AND has a same-page
+// workflow writing to that SAME table renders with getServerSideProps (see
+// teleport-plugin-next-static-props), which resolves params per-request.
+// Next.js does not allow getStaticPaths alongside getServerSideProps, so
+// this plugin must be a no-op for those pages — even when the page has no
+// initialPathsData and would otherwise fall back to emitting a stub
+// getStaticPaths/getStaticProps pair. This is decided by table/workflow
+// correlation, not by the project's visual nav layout.
+
+const TABLE_NAME = 'press_items'
+const PAGE_ID = 'page-edit-press-item'
+
+const makeWorkflows = (tableName: string, scopedToPageId: string | null = PAGE_ID): UIDLWorkflows =>
+  ({
+    workflows: {
+      'update-press-item': {
+        id: 'update-press-item',
+        name: 'Update press item',
+        trigger: {
+          nodeId: 'trigger-1',
+          type: 'event-click',
+          scope: 'element',
+          config: {
+            selectedPages: scopedToPageId ? [{ id: scopedToPageId, name: 'Edit Press Item' }] : [],
+          },
+        },
+        nodes: [
+          {
+            id: 'mutate-1',
+            type: 'data-update-item',
+            label: 'Update item',
+            config: { tableName },
+            executionEnv: 'server',
+            stepNumber: 1,
+          },
+        ],
+        edges: [],
+        usedInNodes: {},
+      },
+    },
+  } as unknown as UIDLWorkflows)
+
+const makeStructure = (params: {
+  folderPath: string[]
+  fileName: string
+  tableName?: string
+  workflows?: UIDLWorkflows
+}): ComponentStructure => {
+  const { folderPath, fileName, tableName, workflows } = params
+  return {
+    uidl: {
+      name: 'EditPressItem',
+      node: { type: 'element', content: { elementType: 'container' } },
+      outputOptions: {
+        pageId: PAGE_ID,
+        folderPath,
+        fileName,
+        ...(tableName && {
+          detailsPageInfo: {
+            dataSourceId: 'ds-1',
+            dataSourceName: 'TeleportHQ database',
+            dataSourceType: 'teleport',
+            tableName,
+            differentiatorColumn: 'id',
+            featureIdentifier: 'pressItem',
+          },
+        }),
+      },
+    },
+    chunks: [{ name: 'jsx-component' }],
+    dependencies: {},
+    options: { workflows, resources: { items: {}, path: ['utils', 'data-sources'] } },
+  } as unknown as ComponentStructure
+}
+
+describe('teleport-plugin-next-static-paths: same-table-mutation getServerSideProps skip', () => {
+  const plugin = createStaticPathsPlugin()
+
+  it('emits no getStaticPaths/getStaticProps chunks when the page reads and a same-page workflow writes the same table', async () => {
+    const structure = makeStructure({
+      folderPath: ['edit-press-item'],
+      fileName: '[id]',
+      tableName: TABLE_NAME,
+      workflows: makeWorkflows(TABLE_NAME),
+    })
+
+    const result = await plugin(structure)
+    expect(result.chunks.find((chunk) => chunk.name === 'getStaticPaths')).toBeUndefined()
+    expect(result.chunks.find((chunk) => chunk.name === 'getStaticProps')).toBeUndefined()
+  })
+
+  it('emits no getStaticPaths for a page that reads a money table — it renders per request', async () => {
+    const structure = makeStructure({
+      folderPath: ['admin', 'vouchers', 'update'],
+      fileName: '[id]',
+      tableName: 'teleport_vouchers',
+      workflows: undefined,
+    })
+
+    const result = await plugin(structure)
+    expect(result.chunks.find((chunk) => chunk.name === 'getStaticPaths')).toBeUndefined()
+    expect(result.chunks.find((chunk) => chunk.name === 'getStaticProps')).toBeUndefined()
+  })
+
+  it('still emits a fallback getStaticPaths when detailsPageInfo is present but no mutation workflow targets its table', async () => {
+    const structure = makeStructure({
+      folderPath: ['view-press-item'],
+      fileName: '[id]',
+      tableName: TABLE_NAME,
+      workflows: undefined,
+    })
+
+    const result = await plugin(structure)
+    expect(result.chunks.find((chunk) => chunk.name === 'getStaticPaths')).toBeDefined()
+    expect(result.chunks.find((chunk) => chunk.name === 'getStaticProps')).toBeDefined()
+  })
+
+  it('still emits a fallback getStaticPaths when the matching-table workflow is scoped to a different page', async () => {
+    const structure = makeStructure({
+      folderPath: ['view-press-item'],
+      fileName: '[id]',
+      tableName: TABLE_NAME,
+      workflows: makeWorkflows(TABLE_NAME, 'some-other-page'),
+    })
+
+    const result = await plugin(structure)
+    expect(result.chunks.find((chunk) => chunk.name === 'getStaticPaths')).toBeDefined()
+  })
+
+  it('still emits a fallback getStaticPaths for a dynamic page with no detailsPageInfo at all (e.g. public blog-post/[id])', async () => {
+    const structure = makeStructure({
+      folderPath: ['blog-post'],
+      fileName: '[id]',
+      tableName: undefined,
+      workflows: undefined,
+    })
+
+    const result = await plugin(structure)
+    expect(result.chunks.find((chunk) => chunk.name === 'getStaticPaths')).toBeDefined()
+    expect(result.chunks.find((chunk) => chunk.name === 'getStaticProps')).toBeDefined()
+  })
+
+  it('is a no-op for a non-dynamic page regardless of workflows (no route param to worry about)', async () => {
+    const structure = makeStructure({
+      folderPath: ['add-press-item'],
+      fileName: 'index',
+      tableName: undefined,
+      workflows: makeWorkflows(TABLE_NAME),
+    })
+
+    const result = await plugin(structure)
+    expect(result.chunks.find((chunk) => chunk.name === 'getStaticPaths')).toBeUndefined()
+    expect(result.chunks.find((chunk) => chunk.name === 'getStaticProps')).toBeUndefined()
+  })
+})

package/__tests__/static-paths-item-hygiene.test.ts

@@ -0,0 +1,71 @@
+import * as types from '@babel/types'
+import generate from '@babel/generator'
+import { generateInitialPathsAST } from '../src/utils'
+import { UIDLInitialPathsData } from '@teleporthq/teleport-types'
+
+const initialPathsData: UIDLInitialPathsData = {
+  exposeAs: { name: 'productPaths', valuePath: ['data'], itemValuePath: ['slug'] },
+  resource: { id: 'TQ_products' },
+}
+
+/**
+ * Evaluates the emitted `getStaticPaths` against a canned response, so these
+ * assert on the paths it actually produces rather than on generated text.
+ */
+const runStaticPaths = async (response: unknown) => {
+  const ast = generateInitialPathsAST(
+    initialPathsData,
+    'fetchProducts',
+    initialPathsData.resource,
+    undefined,
+    'slug'
+  )
+  const { code } = generate(types.program([ast]))
+
+  const factory = new Function(
+    'fetchProducts',
+    `${code.replace('export async function getStaticPaths', 'async function getStaticPaths')}
+    return getStaticPaths`
+  )
+
+  return factory(() => Promise.resolve(response))()
+}
+
+describe('getStaticPaths item hygiene', () => {
+  it('produces one path per record for clean data, in order — unchanged', async () => {
+    const result = await runStaticPaths({ data: [{ slug: 'a' }, { slug: 'b' }, { slug: 'c' }] })
+
+    expect(result.paths).toEqual([
+      { params: { slug: 'a' } },
+      { params: { slug: 'b' } },
+      { params: { slug: 'c' } },
+    ])
+    expect(result.fallback).toBe('blocking')
+  })
+
+  it('stringifies a numeric differentiator, as before', async () => {
+    const result = await runStaticPaths({ data: [{ slug: 1 }, { slug: 2 }] })
+    expect(result.paths).toEqual([{ params: { slug: '1' } }, { params: { slug: '2' } }])
+  })
+
+  it('skips records with no differentiator instead of losing every path', async () => {
+    const result = await runStaticPaths({
+      data: [{ slug: 'a' }, {}, { slug: null }, { slug: '' }, { slug: 'b' }],
+    })
+
+    expect(result.paths).toEqual([{ params: { slug: 'a' } }, { params: { slug: 'b' } }])
+  })
+
+  it('emits one path per distinct differentiator', async () => {
+    const result = await runStaticPaths({
+      data: [{ slug: 'a' }, { slug: 'b' }, { slug: 'a' }],
+    })
+
+    expect(result.paths).toEqual([{ params: { slug: 'a' } }, { params: { slug: 'b' } }])
+  })
+
+  it('returns no paths, not an error, for an empty or absent collection', async () => {
+    expect((await runStaticPaths({ data: [] })).paths).toEqual([])
+    expect((await runStaticPaths({})).paths).toEqual([])
+  })
+})

package/__tests__/visitor-read.test.ts

@@ -0,0 +1,102 @@
+/* tslint:disable:function-constructor */
+import * as types from '@babel/types'
+import generate from '@babel/generator'
+import { ComponentStructure } from '@teleporthq/teleport-types'
+import { createStaticPathsPlugin } from '../src/index'
+
+/**
+ * The rows a details page is pre-rendered for are the rows its reader may see:
+ * listed as the store, a draft product became a page anyone could open by its
+ * slug. A public page lists them as a visitor is served them.
+ */
+
+const RESOURCE_ID = 'fetch-products-paths'
+
+const AUTH = {
+  enabled: true,
+  roles: ['admin'],
+  pageProtection: {
+    'p-admin-products': {
+      requiresAuth: true,
+      allowedRoles: ['admin'],
+      pageName: 'update',
+      route: '/admin/products/update',
+    },
+  },
+  folderProtection: {
+    'f-admin': {
+      requiresAuth: true,
+      allowedRoles: ['admin'],
+      folderName: 'admin-panel',
+      parentId: 'pages',
+      children: { 'p-admin-products': 'page' },
+    },
+  },
+}
+
+const runStaticPaths = async (folderPath: string[], pageId: string) => {
+  const structure = {
+    uidl: {
+      name: 'ProductDetails',
+      node: { type: 'element', content: { elementType: 'container' } },
+      outputOptions: {
+        pageId,
+        folderPath,
+        fileName: '[slug]',
+        dynamicRouteAttribute: 'slug',
+        initialPathsData: {
+          exposeAs: { name: 'productPaths', valuePath: ['data'], itemValuePath: ['slug'] },
+          resource: { id: RESOURCE_ID, params: {} },
+        },
+      },
+    },
+    chunks: [{ name: 'jsx-component', type: 'js', fileType: 'js', content: {}, linkAfter: [] }],
+    dependencies: {},
+    options: {
+      auth: AUTH,
+      resources: {
+        items: {
+          [RESOURCE_ID]: {
+            id: RESOURCE_ID,
+            name: 'fetch-products-paths',
+            params: {
+              dataSourceId: { type: 'static', content: 'ds-1' },
+              dataSourceType: { type: 'static', content: 'teleport' },
+              tableName: { type: 'static', content: 'teleport_products' },
+            },
+          },
+        },
+        path: ['resources'],
+      },
+    },
+  } as unknown as ComponentStructure
+  const result = await createStaticPathsPlugin()(structure)
+  const chunk = result.chunks.find((c) => c.name === 'getStaticPaths')
+  const { code } = generate(types.program([chunk!.content as types.Statement]))
+  const calls: unknown[][] = []
+  const getStaticPaths = new Function(
+    'fetchProductsPathsResource',
+    `${code.replace('export async function getStaticPaths', 'async function getStaticPaths')}
+    return getStaticPaths`
+  )((...args: unknown[]) => {
+    calls.push(args)
+    return Promise.resolve({ data: [{ slug: 'mug' }] })
+  })
+  const result2 = await getStaticPaths()
+  return { calls, paths: result2.paths }
+}
+
+describe('teleport-plugin-next-static-paths: whom the listed rows are read for', () => {
+  it('lists a public page’s rows as a visitor is served them', async () => {
+    const { calls, paths } = await runStaticPaths(['products'], 'p-product')
+
+    expect(calls).toEqual([[{}, { as: 'visitor' }]])
+    expect(paths).toEqual([{ params: { slug: 'mug' } }])
+  })
+
+  it('lists them as the store for an admin page only trusted readers open', async () => {
+    const { calls } = await runStaticPaths(['admin', 'products', 'update'], 'p-admin-products')
+
+    expect(calls).toEqual([[{}]])
+  })
+})

package/dist/cjs/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,eAAe,EACf,sBAAsB,EAIvB,MAAM,4BAA4B,CAAA;AAInC,UAAU,uBAAuB;IAC/B,kBAAkB,CAAC,EAAE,MAAM,CAAA;CAC5B;AAED,eAAO,MAAM,uBAAuB,EAAE,sBAAsB,CAAC,uBAAuB,CA0EnF,CAAA;;AAED,wBAAwC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AACA,OAAO,EAEL,eAAe,EACf,sBAAsB,EAIvB,MAAM,4BAA4B,CAAA;AAKnC,UAAU,uBAAuB;IAC/B,kBAAkB,CAAC,EAAE,MAAM,CAAA;CAC5B;AAUD,eAAO,MAAM,uBAAuB,EAAE,sBAAsB,CAAC,uBAAuB,CAyKnF,CAAA;;AAED,wBAAwC"}

package/dist/cjs/index.js

@@ -1,4 +1,27 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
     function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
     return new (P || (P = Promise))(function (resolve, reject) {
@@ -37,21 +60,81 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createStaticPathsPlugin = void 0;
+var types = __importStar(require("@babel/types"));
 var teleport_types_1 = require("@teleporthq/teleport-types");
 var teleport_shared_1 = require("@teleporthq/teleport-shared");
+var teleport_plugin_common_1 = require("@teleporthq/teleport-plugin-common");
 var utils_1 = require("./utils");
+var isDynamicRoute = teleport_plugin_common_1.RouteUtils.isDynamicRoute, pageDataReadArguments = teleport_plugin_common_1.RouteUtils.pageDataReadArguments, pageHasSameTableMutationWorkflow = teleport_plugin_common_1.RouteUtils.pageHasSameTableMutationWorkflow, pageReadsProtectedTable = teleport_plugin_common_1.RouteUtils.pageReadsProtectedTable, pageSeedsStateFromDataSource = teleport_plugin_common_1.RouteUtils.pageSeedsStateFromDataSource;
 var createStaticPathsPlugin = function (config) {
     var _a = (config || {}).componentChunkName, componentChunkName = _a === void 0 ? 'jsx-component' : _a;
     var staticPathsPlugin = function (structure) { return __awaiter(void 0, void 0, void 0, function () {
-        var uidl, chunks, options, dependencies, resources, resource, isLocalResource, isExternalResource, resourceImportName, usedResource, importPath, componentChunk, getStaticPathsAST;
-        var _a, _b;
-        return __generator(this, function (_c) {
+        var uidl, chunks, options, dependencies, resources, fallbackGetStaticPaths, fallbackGetStaticProps, resource, isLocalResource, isExternalResource, resourceImportName, usedResource, componentChunk, getStaticPathsAST;
+        var _a, _b, _c;
+        return __generator(this, function (_d) {
             uidl = structure.uidl, chunks = structure.chunks, options = structure.options, dependencies = structure.dependencies;
             resources = options.resources;
+            // Entity-bound dynamic-route pages with a same-page mutation workflow
+            // render with getServerSideProps instead (see `createStaticPropsPlugin` /
+            // `pageHasSameTableMutationWorkflow`'s doc in
+            // `teleport-plugin-common/src/utils/route-utils.ts`), which resolves
+            // params per-request — Next.js does not allow (and does not need) a
+            // getStaticPaths alongside getServerSideProps on the same page. A page
+            // that seeds a state from a data source renders per request too (see
+            // `pageSeedsStateFromDataSource`).
+            if (isDynamicRoute(uidl) &&
+                (pageHasSameTableMutationWorkflow(uidl, options.workflows) ||
+                    pageReadsProtectedTable(uidl) ||
+                    pageSeedsStateFromDataSource(uidl, options.dataSources))) {
+                return [2 /*return*/, structure];
+            }
             if (!((_a = uidl.outputOptions) === null || _a === void 0 ? void 0 : _a.initialPathsData)) {
+                // For dynamic routes without initialPathsData,
+                // generate a fallback getStaticPaths with empty paths and fallback: 'blocking'.
+                // This is needed because Next.js requires getStaticPaths for any dynamic route
+                // that uses getStaticProps (which may be added later by the i18n or data source plugins).
+                if (isDynamicRoute(uidl)) {
+                    fallbackGetStaticPaths = types.exportNamedDeclaration((function () {
+                        var node = types.functionDeclaration(types.identifier('getStaticPaths'), [], types.blockStatement([
+                            types.returnStatement(types.objectExpression([
+                                types.objectProperty(types.identifier('paths'), types.arrayExpression([])),
+                                types.objectProperty(types.identifier('fallback'), types.stringLiteral('blocking')),
+                            ])),
+                        ]), false, true);
+                        node.async = true;
+                        return node;
+                    })());
+                    chunks.push({
+                        name: 'getStaticPaths',
+                        type: teleport_types_1.ChunkType.AST,
+                        fileType: teleport_types_1.FileType.JS,
+                        content: fallbackGetStaticPaths,
+                        linkAfter: [componentChunkName],
+                    });
+                    // Next.js requires getStaticProps when getStaticPaths is present.
+                    // Generate a minimal getStaticProps if no initialPropsData will provide one.
+                    if (!((_b = uidl.outputOptions) === null || _b === void 0 ? void 0 : _b.initialPropsData)) {
+                        fallbackGetStaticProps = types.exportNamedDeclaration((function () {
+                            var node = types.functionDeclaration(types.identifier('getStaticProps'), [types.identifier('context')], types.blockStatement([
+                                types.returnStatement(types.objectExpression([
+                                    types.objectProperty(types.identifier('props'), types.objectExpression([])),
+                                ])),
+                            ]), false, true);
+                            node.async = true;
+                            return node;
+                        })());
+                        chunks.push({
+                            name: 'getStaticProps',
+                            type: teleport_types_1.ChunkType.AST,
+                            fileType: teleport_types_1.FileType.JS,
+                            content: fallbackGetStaticProps,
+                            linkAfter: ['getStaticPaths'],
+                        });
+                    }
+                }
                 return [2 /*return*/, structure];
             }
-            resource = ((_b = uidl === null || uidl === void 0 ? void 0 : uidl.outputOptions) === null || _b === void 0 ? void 0 : _b.initialPathsData).resource;
+            resource = ((_c = uidl === null || uidl === void 0 ? void 0 : uidl.outputOptions) === null || _c === void 0 ? void 0 : _c.initialPathsData).resource;
             isLocalResource = 'id' in resource;
             isExternalResource = 'name' in resource;
             if (isLocalResource) {
@@ -60,10 +143,13 @@ var createStaticPathsPlugin = function (config) {
                     throw new teleport_types_1.TeleportError("Resource ".concat(resource.id, " is being used, but missing from the project ressources"));
                 }
                 resourceImportName = teleport_shared_1.StringUtils.dashCaseToCamelCase(teleport_shared_1.StringUtils.camelCaseToDashCase("".concat(usedResource.name, "-resource")));
-                importPath = "".concat(resources.path).concat(teleport_shared_1.StringUtils.camelCaseToDashCase(usedResource.name));
                 dependencies[resourceImportName] = {
                     type: 'local',
-                    path: importPath,
+                    path: "".concat(teleport_shared_1.GenericUtils.generatePageDependenciesPrefix({
+                        toPath: resources.path,
+                        folderPath: uidl.outputOptions.folderPath,
+                        pagesPath: options.pagesPath,
+                    })).concat(teleport_shared_1.StringUtils.camelCaseToDashCase(usedResource.name)),
                 };
             }
             if (isExternalResource) {
@@ -74,7 +160,10 @@ var createStaticPathsPlugin = function (config) {
             if (!componentChunk) {
                 return [2 /*return*/, structure];
             }
-            getStaticPathsAST = (0, utils_1.generateInitialPathsAST)(uidl.outputOptions.initialPathsData, resourceImportName, resource, uidl.outputOptions.pagination);
+            getStaticPathsAST = (0, utils_1.generateInitialPathsAST)(uidl.outputOptions.initialPathsData, resourceImportName, resource, uidl.outputOptions.pagination, uidl.outputOptions.dynamicRouteAttribute, 
+            // A resource the project generated forwards it to the data-source module;
+            // another package's function takes its own arguments.
+            isLocalResource ? pageDataReadArguments(uidl, options.auth) : []);
             chunks.push({
                 name: 'getStaticPaths',
                 type: teleport_types_1.ChunkType.AST,

package/dist/cjs/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,6DAOmC;AACnC,+DAAyD;AACzD,iCAAiD;AAM1C,IAAM,uBAAuB,GAAoD,UACtF,MAAM;IAEE,IAAA,KAAyC,CAAA,MAAM,IAAI,EAAE,CAAA,mBAAjB,EAApC,kBAAkB,mBAAG,eAAe,KAAA,CAAiB;IAE7D,IAAM,iBAAiB,GAAoB,UAAO,SAAS;;;;YACjD,IAAI,GAAoC,SAAS,KAA7C,EAAE,MAAM,GAA4B,SAAS,OAArC,EAAE,OAAO,GAAmB,SAAS,QAA5B,EAAE,YAAY,GAAK,SAAS,aAAd,CAAc;YACjD,SAAS,GAAK,OAAO,UAAZ,CAAY;YAE7B,IAAI,CAAC,CAAA,MAAA,IAAI,CAAC,aAAa,0CAAE,gBAAgB,CAAA,EAAE;gBACzC,sBAAO,SAAS,EAAA;aACjB;YAEO,QAAQ,GAAK,CAAA,MAAA,IAAI,aAAJ,IAAI,uBAAJ,IAAI,CAAE,aAAa,0CAAE,gBAAgB,CAAA,SAA1C,CAA0C;YAEpD,eAAe,GAAG,IAAI,IAAI,QAAQ,CAAA;YAClC,kBAAkB,GAAG,MAAM,IAAI,QAAQ,CAAA;YAM7C,IAAI,eAAe,EAAE;gBACb,YAAY,GAAG,SAAS,CAAC,KAAK,CAAE,QAA8B,CAAC,EAAE,CAAC,CAAA;gBAExE,IAAI,CAAC,YAAY,EAAE;oBACjB,MAAM,IAAI,8BAAa,CACrB,mBACG,QAA8B,CAAC,EAAE,4DACqB,CAC1D,CAAA;iBACF;gBAED,kBAAkB,GAAG,6BAAW,CAAC,mBAAmB,CAClD,6BAAW,CAAC,mBAAmB,CAAC,UAAG,YAAY,CAAC,IAAI,cAAW,CAAC,CACjE,CAAA;gBAEK,UAAU,GAAG,UAAG,SAAS,CAAC,IAAI,SAAG,6BAAW,CAAC,mBAAmB,CAAC,YAAY,CAAC,IAAI,CAAC,CAAE,CAAA;gBAE3F,YAAY,CAAC,kBAAkB,CAAC,GAAG;oBACjC,IAAI,EAAE,OAAO;oBACb,IAAI,EAAE,UAAU;iBACjB,CAAA;aACF;YAED,IAAI,kBAAkB,EAAE;gBACtB,kBAAkB,GAAG,QAAQ,CAAC,IAAI,CAAA;gBAClC,YAAY,CAAC,QAAQ,CAAC,IAAI,CAAC,GAAG,QAAQ,CAAC,UAAU,CAAA;aAClD;YAEK,cAAc,GAAG,MAAM,CAAC,IAAI,CAAC,UAAC,KAAK,IAAK,OAAA,KAAK,CAAC,IAAI,KAAK,kBAAkB,EAAjC,CAAiC,CAAC,CAAA;YAChF,IAAI,CAAC,cAAc,EAAE;gBACnB,sBAAO,SAAS,EAAA;aACjB;YAEK,iBAAiB,GAAG,IAAA,+BAAuB,EAC/C,IAAI,CAAC,aAAa,CAAC,gBAAgB,EACnC,kBAAkB,EAClB,QAAQ,EACR,IAAI,CAAC,aAAa,CAAC,UAAU,CAC9B,CAAA;YAED,MAAM,CAAC,IAAI,CAAC;gBACV,IAAI,EAAE,gBAAgB;gBACtB,IAAI,EAAE,0BAAS,CAAC,GAAG;gBACnB,QAAQ,EAAE,yBAAQ,CAAC,EAAE;gBACrB,OAAO,EAAE,iBAAiB;gBAC1B,SAAS,EAAE,CAAC,kBAAkB,CAAC;aAChC,CAAC,CAAA;YAEF,sBAAO,SAAS,EAAA;;SACjB,CAAA;IAED,OAAO,iBAAiB,CAAA;AAC1B,CAAC,CAAA;AA1EY,QAAA,uBAAuB,2BA0EnC;AAED,kBAAe,IAAA,+BAAuB,GAAE,CAAA"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"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"}