@stackone/connect-sdk 1.6.0 → 1.8.0

package/dist/index.es.mjs

@@ -1 +1 @@
-import{StepFunctionName as s,StepFunctionsFactory as t}from"@stackone/core";const o=async({block:o,stepFunctionName:c,params:r,buildStepFunction:e=t.build})=>{const u=e({functionName:c}),a=await u({block:o,params:r}),l=c===s.MAP_FIELDS?{[s.MAP_FIELDS.toString()]:{output:{data:a.block.result},errors:a.errors,successfull:a.successfull}}:{};return{...a.block,steps:{...a?.block?.steps??{},...l}}};export{o as executeStepFunction};
+import{StepFunctionName as t,StepFunctionsFactory as e,AUTHENTICATION_SCHEMA as n}from"@stackone/core";import{safeEvaluate as o}from"@stackone/expressions";import{parse as r}from"yaml";import{z as i}from"zod";import{HttpClientManager as s}from"@stackone/transport";const a=async({block:n,stepFunctionName:o,params:r,buildStepFunction:i=e.build})=>{const s=i({functionName:o}).fn,a=await s({block:n,params:r}),c=o===t.MAP_FIELDS?{[t.MAP_FIELDS.toString()]:{output:{data:a.block.result},errors:a.errors,successful:a.successful}}:{};return{...a.block,steps:{...a?.block?.steps??{},...c}}},c=async({block:t,buildStepFunction:n=e.build})=>{const r=t.operation?.steps||[];let i={...t};const s=Object.keys(r);for(const t of s){const e=r[t].stepFunction,o=n({functionName:e.functionName,version:e.version,validateSchemas:!0}).fn,s=await o({block:i,params:e.params});i={...s.block,steps:{...s.block.steps,[t]:{successful:s.successful,errors:s.errors,output:s.output}}}}const a=t.operation?.result?o(t.operation.result,i):void 0;return{...i,outputs:a}},p=i.object({StackOne:i.string(),info:i.object({title:i.string(),version:i.string(),key:i.string(),description:i.string().optional(),categories:i.array(i.string())}),baseUrl:i.string(),authentication:i.record(i.string(),i.object({type:i.string(),label:i.string(),authorization:n,environments:i.record(i.string(),i.object({key:i.string(),name:i.string()})).array()})).array().optional(),operations:i.object({operationId:i.string(),operationType:i.string(),schema:i.string().optional(),entrypointUrl:i.string().optional(),entrypointHttpMethod:i.string().optional(),description:i.string(),inputs:i.object({name:i.string(),type:i.string(),required:i.boolean(),description:i.string(),in:i.string()}).array().optional(),fieldConfigs:i.object({targetFieldKey:i.string(),expression:i.string(),type:i.string(),isUnified:i.boolean()}).array(),steps:i.object({stepId:i.string(),description:i.string(),stepFunction:i.object({functionName:i.string(),version:i.string().optional(),parameters:i.record(i.string(),i.unknown())})}).array(),result:i.string()}).array()});function u(t){try{const e=r(t),n=p.parse(e),o={title:n.info.title,version:n.info.version,key:n.info.key,description:n.info.description,categories:n.info.categories},i=l(n),s={baseUrl:n.baseUrl,authentication:i},a=d(n,s);return o.operations=a,o}catch(t){throw new Error(`Error parsing YAML file: ${t.message}`)}}const l=t=>{const e={};for(const n of t.authentication??[]){const[t]=Object.keys(n),o=n[t].environments.reduce(((e,o)=>{const[r]=Object.values(o),{environments:i,...s}=n[t];return e[r.key]={...s,envKey:r.key,envName:r.name},e}),{});e[t]=o}return e},d=(t,e)=>t.operations.reduce(((t,n)=>{const o=(t=>t.entrypointUrl&&t.entrypointHttpMethod?`${t.entrypointHttpMethod.toUpperCase()} ${t.entrypointUrl}`:void 0)(n),r=(t=>"list"===t.operationType?`GET /${t.schema}`:`GET /${t.schema}/:id`)(n),i=(t=>"list"===t.operationType?`/${t.schema}`:`/${t.schema}/:id`)(n);return t[o??r]={id:n.operationId,description:n.description,operationType:n.operationType,entrypointUrl:n.entrypointUrl??i,entrypointHttpMethod:n.entrypointHttpMethod??"get",inputs:n.inputs,steps:n.steps.reduce(((t,o)=>(t[o.stepId]={id:o.stepId,description:o.description,stepFunction:{functionName:o.stepFunction.functionName,version:o.stepFunction.version,params:{..."request"===o.stepFunction.functionName?e:{},..."map_fields"===o.stepFunction.functionName||"typecast"===o.stepFunction.functionName?{fields:n.fieldConfigs}:{},...o.stepFunction.parameters}}},t)),{}),result:n.result},t}),{}),y=(t,e)=>{if(!t.inputs)return{};const n=m(t.inputs).parse(e);return{...n.headers??{},...n.query??{},...n.path??{},...n.body??{}}},g=t=>{const e={};return t.forEach((t=>{let n;switch(t.type.toLowerCase()){case"string":n=i.string();break;case"number":n=i.number();break;case"boolean":n=i.boolean();break;default:n=i.any()}e[t.name]=t.required?n:n.optional()})),i.object(e)},m=t=>{const e=t.filter((t=>"path"===t.in)),n=t.filter((t=>"query"===t.in)),o=t.filter((t=>"body"===t.in)),r=t.filter((t=>"headers"===t.in));return i.object({path:g(e).optional(),query:g(n).optional(),body:g(o).optional(),headers:g(r).optional()})},f=async({inputs:t,category:e,providerKey:n,authConfigKey:o,environment:r="production",operation:i,accountSecureId:a,projectSecureId:c,credentials:p,logger:u,getHttpClient:l=async()=>s.getInstance()})=>{const d=await l();return{inputs:t,fieldConfigs:[],context:{projectSecureId:c,accountSecureId:a,connector:n,category:e,schema:i.schema?.key,service:"",resource:"",operationType:i.operationType,authenticationType:o,environment:r},operation:i,credentials:p,httpClient:d,logger:u}};export{f as createBlock,a as executeStepFunction,y as parseOperationInputs,u as parseYamlConnector,c as runStepOperation};

package/dist/index.js

@@ -1 +1 @@
-"use strict";var t=require("@stackone/core");exports.executeStepFunction=async({block:e,stepFunctionName:c,params:s,buildStepFunction:o=t.StepFunctionsFactory.build})=>{const u=o({functionName:c}),n=await u({block:e,params:s}),r=c===t.StepFunctionName.MAP_FIELDS?{[t.StepFunctionName.MAP_FIELDS.toString()]:{output:{data:n.block.result},errors:n.errors,successfull:n.successfull}}:{};return{...n.block,steps:{...n?.block?.steps??{},...r}}};
+"use strict";var t=require("@stackone/core"),e=require("@stackone/expressions"),n=require("yaml"),r=require("zod"),o=require("@stackone/transport");const i=r.z.object({StackOne:r.z.string(),info:r.z.object({title:r.z.string(),version:r.z.string(),key:r.z.string(),description:r.z.string().optional(),categories:r.z.array(r.z.string())}),baseUrl:r.z.string(),authentication:r.z.record(r.z.string(),r.z.object({type:r.z.string(),label:r.z.string(),authorization:t.AUTHENTICATION_SCHEMA,environments:r.z.record(r.z.string(),r.z.object({key:r.z.string(),name:r.z.string()})).array()})).array().optional(),operations:r.z.object({operationId:r.z.string(),operationType:r.z.string(),schema:r.z.string().optional(),entrypointUrl:r.z.string().optional(),entrypointHttpMethod:r.z.string().optional(),description:r.z.string(),inputs:r.z.object({name:r.z.string(),type:r.z.string(),required:r.z.boolean(),description:r.z.string(),in:r.z.string()}).array().optional(),fieldConfigs:r.z.object({targetFieldKey:r.z.string(),expression:r.z.string(),type:r.z.string(),isUnified:r.z.boolean()}).array(),steps:r.z.object({stepId:r.z.string(),description:r.z.string(),stepFunction:r.z.object({functionName:r.z.string(),version:r.z.string().optional(),parameters:r.z.record(r.z.string(),r.z.unknown())})}).array(),result:r.z.string()}).array()});const s=t=>{const e={};for(const n of t.authentication??[]){const[t]=Object.keys(n),r=n[t].environments.reduce(((e,r)=>{const[o]=Object.values(r),{environments:i,...s}=n[t];return e[o.key]={...s,envKey:o.key,envName:o.name},e}),{});e[t]=r}return e},a=(t,e)=>t.operations.reduce(((t,n)=>{const r=(t=>t.entrypointUrl&&t.entrypointHttpMethod?`${t.entrypointHttpMethod.toUpperCase()} ${t.entrypointUrl}`:void 0)(n),o=(t=>"list"===t.operationType?`GET /${t.schema}`:`GET /${t.schema}/:id`)(n),i=(t=>"list"===t.operationType?`/${t.schema}`:`/${t.schema}/:id`)(n);return t[r??o]={id:n.operationId,description:n.description,operationType:n.operationType,entrypointUrl:n.entrypointUrl??i,entrypointHttpMethod:n.entrypointHttpMethod??"get",inputs:n.inputs,steps:n.steps.reduce(((t,r)=>(t[r.stepId]={id:r.stepId,description:r.description,stepFunction:{functionName:r.stepFunction.functionName,version:r.stepFunction.version,params:{..."request"===r.stepFunction.functionName?e:{},..."map_fields"===r.stepFunction.functionName||"typecast"===r.stepFunction.functionName?{fields:n.fieldConfigs}:{},...r.stepFunction.parameters}}},t)),{}),result:n.result},t}),{}),c=t=>{const e={};return t.forEach((t=>{let n;switch(t.type.toLowerCase()){case"string":n=r.z.string();break;case"number":n=r.z.number();break;case"boolean":n=r.z.boolean();break;default:n=r.z.any()}e[t.name]=t.required?n:n.optional()})),r.z.object(e)},p=t=>{const e=t.filter((t=>"path"===t.in)),n=t.filter((t=>"query"===t.in)),o=t.filter((t=>"body"===t.in)),i=t.filter((t=>"headers"===t.in));return r.z.object({path:c(e).optional(),query:c(n).optional(),body:c(o).optional(),headers:c(i).optional()})};exports.createBlock=async({inputs:t,category:e,providerKey:n,authConfigKey:r,environment:i="production",operation:s,accountSecureId:a,projectSecureId:c,credentials:p,logger:u,getHttpClient:l=async()=>o.HttpClientManager.getInstance()})=>{const d=await l();return{inputs:t,fieldConfigs:[],context:{projectSecureId:c,accountSecureId:a,connector:n,category:e,schema:s.schema?.key,service:"",resource:"",operationType:s.operationType,authenticationType:r,environment:i},operation:s,credentials:p,httpClient:d,logger:u}},exports.executeStepFunction=async({block:e,stepFunctionName:n,params:r,buildStepFunction:o=t.StepFunctionsFactory.build})=>{const i=o({functionName:n}).fn,s=await i({block:e,params:r}),a=n===t.StepFunctionName.MAP_FIELDS?{[t.StepFunctionName.MAP_FIELDS.toString()]:{output:{data:s.block.result},errors:s.errors,successful:s.successful}}:{};return{...s.block,steps:{...s?.block?.steps??{},...a}}},exports.parseOperationInputs=(t,e)=>{if(!t.inputs)return{};const n=p(t.inputs).parse(e);return{...n.headers??{},...n.query??{},...n.path??{},...n.body??{}}},exports.parseYamlConnector=function(t){try{const e=n.parse(t),r=i.parse(e),o={title:r.info.title,version:r.info.version,key:r.info.key,description:r.info.description,categories:r.info.categories},c=s(r),p={baseUrl:r.baseUrl,authentication:c},u=a(r,p);return o.operations=u,o}catch(t){throw new Error(`Error parsing YAML file: ${t.message}`)}},exports.runStepOperation=async({block:n,buildStepFunction:r=t.StepFunctionsFactory.build})=>{const o=n.operation?.steps||[];let i={...n};const s=Object.keys(o);for(const t of s){const e=o[t].stepFunction,n=r({functionName:e.functionName,version:e.version,validateSchemas:!0}).fn,s=await n({block:i,params:e.params});i={...s.block,steps:{...s.block.steps,[t]:{successful:s.successful,errors:s.errors,output:s.output}}}}const a=n.operation?.result?e.safeEvaluate(n.operation.result,i):void 0;return{...i,outputs:a}};

package/dist/types/blocks/createBlock.d.ts

@@ -0,0 +1,15 @@
+import { Block, Category, ILogger, Operation } from '@stackone/core';
+import { IHttpClient } from '@stackone/transport';
+export declare const createBlock: ({ inputs, category, providerKey, authConfigKey, environment, operation, accountSecureId, projectSecureId, credentials, logger, getHttpClient, }: {
+    inputs?: Record<string, unknown>;
+    category: Category;
+    providerKey: string;
+    authConfigKey: string;
+    environment?: string;
+    operation: Operation;
+    accountSecureId: string;
+    projectSecureId: string;
+    credentials?: Record<string, unknown>;
+    logger?: ILogger;
+    getHttpClient?: () => Promise<IHttpClient>;
+}) => Promise<Block>;

package/dist/types/connectors/operations.d.ts

@@ -0,0 +1,6 @@
+import { Connector, Operation } from '@stackone/core';
+import { HttpMethod } from '@stackone/transport';
+export declare const getOperationFromUrl: (connector: Connector, url: string, method: HttpMethod) => {
+    operation: Operation;
+    params: Partial<Record<string, string | string[]>>;
+} | undefined;

package/dist/types/connectors/parsers.d.ts

@@ -0,0 +1,3 @@
+import { Connector, Operation } from '@stackone/core';
+export declare function parseYamlConnector(yamlFileContents: string): Connector;
+export declare const parseOperationInputs: (operation: Operation, inputs: unknown) => Record<string, unknown>;

package/dist/types/connectors/schemas.d.ts

@@ -0,0 +1,348 @@
+import { z } from 'zod';
+export declare const CONNECTOR_YAML_SCHEMA: z.ZodObject<{
+    StackOne: z.ZodString;
+    info: z.ZodObject<{
+        title: z.ZodString;
+        version: z.ZodString;
+        key: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        categories: z.ZodArray<z.ZodString, "many">;
+    }, "strip", z.ZodTypeAny, {
+        title: string;
+        version: string;
+        key: string;
+        categories: string[];
+        description?: string | undefined;
+    }, {
+        title: string;
+        version: string;
+        key: string;
+        categories: string[];
+        description?: string | undefined;
+    }>;
+    baseUrl: z.ZodString;
+    authentication: z.ZodOptional<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodObject<{
+        type: z.ZodString;
+        label: z.ZodString;
+        authorization: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+            type: z.ZodLiteral<"basic">;
+            username: z.ZodString;
+            password: z.ZodString;
+            encoding: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            type: "basic";
+            username: string;
+            password: string;
+            encoding?: string | undefined;
+        }, {
+            type: "basic";
+            username: string;
+            password: string;
+            encoding?: string | undefined;
+        }>, z.ZodObject<{
+            type: z.ZodLiteral<"bearer">;
+            token: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            type: "bearer";
+            token: string;
+        }, {
+            type: "bearer";
+            token: string;
+        }>]>;
+        environments: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodObject<{
+            key: z.ZodString;
+            name: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            key: string;
+            name: string;
+        }, {
+            key: string;
+            name: string;
+        }>>, "many">;
+    }, "strip", z.ZodTypeAny, {
+        type: string;
+        label: string;
+        authorization: {
+            type: "basic";
+            username: string;
+            password: string;
+            encoding?: string | undefined;
+        } | {
+            type: "bearer";
+            token: string;
+        };
+        environments: Record<string, {
+            key: string;
+            name: string;
+        }>[];
+    }, {
+        type: string;
+        label: string;
+        authorization: {
+            type: "basic";
+            username: string;
+            password: string;
+            encoding?: string | undefined;
+        } | {
+            type: "bearer";
+            token: string;
+        };
+        environments: Record<string, {
+            key: string;
+            name: string;
+        }>[];
+    }>>, "many">>;
+    operations: z.ZodArray<z.ZodObject<{
+        operationId: z.ZodString;
+        operationType: z.ZodString;
+        schema: z.ZodOptional<z.ZodString>;
+        entrypointUrl: z.ZodOptional<z.ZodString>;
+        entrypointHttpMethod: z.ZodOptional<z.ZodString>;
+        description: z.ZodString;
+        inputs: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            type: z.ZodString;
+            required: z.ZodBoolean;
+            description: z.ZodString;
+            in: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            type: string;
+            description: string;
+            name: string;
+            required: boolean;
+            in: string;
+        }, {
+            type: string;
+            description: string;
+            name: string;
+            required: boolean;
+            in: string;
+        }>, "many">>;
+        fieldConfigs: z.ZodArray<z.ZodObject<{
+            targetFieldKey: z.ZodString;
+            expression: z.ZodString;
+            type: z.ZodString;
+            isUnified: z.ZodBoolean;
+        }, "strip", z.ZodTypeAny, {
+            type: string;
+            targetFieldKey: string;
+            expression: string;
+            isUnified: boolean;
+        }, {
+            type: string;
+            targetFieldKey: string;
+            expression: string;
+            isUnified: boolean;
+        }>, "many">;
+        steps: z.ZodArray<z.ZodObject<{
+            stepId: z.ZodString;
+            description: z.ZodString;
+            stepFunction: z.ZodObject<{
+                functionName: z.ZodString;
+                version: z.ZodOptional<z.ZodString>;
+                parameters: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+            }, "strip", z.ZodTypeAny, {
+                functionName: string;
+                parameters: Record<string, unknown>;
+                version?: string | undefined;
+            }, {
+                functionName: string;
+                parameters: Record<string, unknown>;
+                version?: string | undefined;
+            }>;
+        }, "strip", z.ZodTypeAny, {
+            description: string;
+            stepId: string;
+            stepFunction: {
+                functionName: string;
+                parameters: Record<string, unknown>;
+                version?: string | undefined;
+            };
+        }, {
+            description: string;
+            stepId: string;
+            stepFunction: {
+                functionName: string;
+                parameters: Record<string, unknown>;
+                version?: string | undefined;
+            };
+        }>, "many">;
+        result: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        description: string;
+        operationId: string;
+        operationType: string;
+        fieldConfigs: {
+            type: string;
+            targetFieldKey: string;
+            expression: string;
+            isUnified: boolean;
+        }[];
+        steps: {
+            description: string;
+            stepId: string;
+            stepFunction: {
+                functionName: string;
+                parameters: Record<string, unknown>;
+                version?: string | undefined;
+            };
+        }[];
+        result: string;
+        schema?: string | undefined;
+        entrypointUrl?: string | undefined;
+        entrypointHttpMethod?: string | undefined;
+        inputs?: {
+            type: string;
+            description: string;
+            name: string;
+            required: boolean;
+            in: string;
+        }[] | undefined;
+    }, {
+        description: string;
+        operationId: string;
+        operationType: string;
+        fieldConfigs: {
+            type: string;
+            targetFieldKey: string;
+            expression: string;
+            isUnified: boolean;
+        }[];
+        steps: {
+            description: string;
+            stepId: string;
+            stepFunction: {
+                functionName: string;
+                parameters: Record<string, unknown>;
+                version?: string | undefined;
+            };
+        }[];
+        result: string;
+        schema?: string | undefined;
+        entrypointUrl?: string | undefined;
+        entrypointHttpMethod?: string | undefined;
+        inputs?: {
+            type: string;
+            description: string;
+            name: string;
+            required: boolean;
+            in: string;
+        }[] | undefined;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    StackOne: string;
+    info: {
+        title: string;
+        version: string;
+        key: string;
+        categories: string[];
+        description?: string | undefined;
+    };
+    baseUrl: string;
+    operations: {
+        description: string;
+        operationId: string;
+        operationType: string;
+        fieldConfigs: {
+            type: string;
+            targetFieldKey: string;
+            expression: string;
+            isUnified: boolean;
+        }[];
+        steps: {
+            description: string;
+            stepId: string;
+            stepFunction: {
+                functionName: string;
+                parameters: Record<string, unknown>;
+                version?: string | undefined;
+            };
+        }[];
+        result: string;
+        schema?: string | undefined;
+        entrypointUrl?: string | undefined;
+        entrypointHttpMethod?: string | undefined;
+        inputs?: {
+            type: string;
+            description: string;
+            name: string;
+            required: boolean;
+            in: string;
+        }[] | undefined;
+    }[];
+    authentication?: Record<string, {
+        type: string;
+        label: string;
+        authorization: {
+            type: "basic";
+            username: string;
+            password: string;
+            encoding?: string | undefined;
+        } | {
+            type: "bearer";
+            token: string;
+        };
+        environments: Record<string, {
+            key: string;
+            name: string;
+        }>[];
+    }>[] | undefined;
+}, {
+    StackOne: string;
+    info: {
+        title: string;
+        version: string;
+        key: string;
+        categories: string[];
+        description?: string | undefined;
+    };
+    baseUrl: string;
+    operations: {
+        description: string;
+        operationId: string;
+        operationType: string;
+        fieldConfigs: {
+            type: string;
+            targetFieldKey: string;
+            expression: string;
+            isUnified: boolean;
+        }[];
+        steps: {
+            description: string;
+            stepId: string;
+            stepFunction: {
+                functionName: string;
+                parameters: Record<string, unknown>;
+                version?: string | undefined;
+            };
+        }[];
+        result: string;
+        schema?: string | undefined;
+        entrypointUrl?: string | undefined;
+        entrypointHttpMethod?: string | undefined;
+        inputs?: {
+            type: string;
+            description: string;
+            name: string;
+            required: boolean;
+            in: string;
+        }[] | undefined;
+    }[];
+    authentication?: Record<string, {
+        type: string;
+        label: string;
+        authorization: {
+            type: "basic";
+            username: string;
+            password: string;
+            encoding?: string | undefined;
+        } | {
+            type: "bearer";
+            token: string;
+        };
+        environments: Record<string, {
+            key: string;
+            name: string;
+        }>[];
+    }>[] | undefined;
+}>;

package/dist/types/connectors/specs/examples/testConnector.d.ts

@@ -0,0 +1,2 @@
+import { Connector } from '@stackone/core';
+export declare const StackOneTestConnector: Connector;

package/dist/types/index.d.ts

@@ -1 +1,4 @@
-export { executeStepFunction } from './executeStepFunctions';
+export { executeStepFunction } from './runners/executeStepFunctions';
+export { runStepOperation } from './runners/runStepOperation';
+export { parseYamlConnector, parseOperationInputs } from './connectors/parsers';
+export { createBlock } from './blocks/createBlock';

package/dist/types/runners/runStepOperation.d.ts

@@ -0,0 +1,5 @@
+import { Block, StepFunctionsFactory } from '@stackone/core';
+export declare const runStepOperation: ({ block, buildStepFunction, }: {
+    block: Block;
+    buildStepFunction?: typeof StepFunctionsFactory.build;
+}) => Promise<Block>;

package/package.json

@@ -1,11 +1,10 @@
 {
     "name": "@stackone/connect-sdk",
-    "version": "1.6.0",
+    "version": "1.8.0",
     "description": "",
     "main": "dist/index.js",
     "module": "dist/index.es.mjs",
     "types": "dist/types/index.d.ts",
-    "devDependencies": {},
     "files": [
         "dist",
         "package.json",
@@ -25,8 +24,8 @@
         "code:check:fix": "biome check --write ./src ./*.mjs",
         "lint": "npm run code:check",
         "lint:fix": "npm run code:check:fix",
-        "test": "vitest run",
-        "test:watch": "vitest watch",
+        "test": "FORCE_COLOR=1 vitest run",
+        "test:watch": "FORCE_COLOR=1 vitest watch --silent",
         "publish-release": "npm publish --access=public"
     },
     "keywords": [],
@@ -34,7 +33,9 @@
     "license": "ISC",
     "dependencies": {
         "@stackone/core": "*",
+        "@stackone/expressions": "*",
+        "@stackone/open-api": "*",
         "@stackone/transport": "*",
-        "@stackone/open-api": "*"
+        "path-to-regexp": "^8.2.0"
     }
 }