@platformatic/runtime 0.30.0 → 0.31.0

package/fixtures/typescript/services/movies/.env

@@ -0,0 +1,4 @@
+PLT_SERVER_HOSTNAME=127.0.0.1
+PORT=3001
+PLT_SERVER_LOGGER_LEVEL=info
+DATABASE_URL=sqlite://./db.sqlite

package/fixtures/typescript-custom-flags/platformatic.runtime.json

@@ -0,0 +1,12 @@
+{
+  "$schema": "https://platformatic.dev/schemas/v0.28.1/runtime",
+  "entrypoint": "composer",
+  "allowCycles": false,
+  "hotReload": true,
+  "autoload": {
+    "path": "services",
+    "exclude": [
+      "docs"
+    ]
+  }
+}

package/fixtures/typescript-custom-flags/services/composer/platformatic.composer.json

@@ -0,0 +1,28 @@
+{
+  "$schema": "https://platformatic.dev/schemas/v0.28.1/composer",
+  "server": {
+    "hostname": "{PLT_SERVER_HOSTNAME}",
+    "port": "{PORT}",
+    "logger": {
+      "level": "{PLT_SERVER_LOGGER_LEVEL}"
+    }
+  },
+  "composer": {
+    "services": [
+      {
+        "id": "movies",
+        "openapi": {
+          "url": "/documentation/json"
+        }
+      },
+      {
+        "id": "titles",
+        "openapi": {
+          "url": "/documentation/json"
+        }
+      }
+    ],
+    "refreshTimeout": 1000
+  },
+  "watch": true
+}

package/fixtures/typescript-custom-flags/services/movies/global.d.ts

@@ -0,0 +1,24 @@
+import { Entity } from '@platformatic/sql-mapper';
+import graphqlPlugin from '@platformatic/sql-graphql'
+import { EntityTypes, Movie } from './types'
+
+declare module 'fastify' {
+  interface FastifyInstance {
+    getSchema<T extends 'Movie'>(schemaId: T): {
+      '$id': string,
+      title: string,
+      description: string,
+      type: string,
+      properties: {
+        [x in keyof EntityTypes[T]]: { type: string, nullable?: boolean }
+      },
+      required: string[]
+    };
+  }
+}
+
+declare module '@platformatic/sql-mapper' {
+  interface Entities {
+    movie: Entity<Movie>,
+  }
+}

package/fixtures/typescript-custom-flags/services/movies/migrations/001.do.sql

@@ -0,0 +1,6 @@
+
+-- Add SQL in this file to create the database tables for your API
+CREATE TABLE IF NOT EXISTS movies (
+  id INTEGER PRIMARY KEY,
+  title TEXT NOT NULL
+);

package/fixtures/typescript-custom-flags/services/movies/migrations/001.undo.sql

@@ -0,0 +1,3 @@
+
+-- Add SQL in this file to drop the database tables 
+DROP TABLE movies;

package/fixtures/typescript-custom-flags/services/movies/platformatic.db.json

@@ -0,0 +1,35 @@
+{
+  "$schema": "https://platformatic.dev/schemas/v0.30.0/db",
+  "server": {
+    "hostname": "{PLT_SERVER_HOSTNAME}",
+    "port": "{PORT}",
+    "logger": {
+      "level": "{PLT_SERVER_LOGGER_LEVEL}"
+    }
+  },
+  "db": {
+    "connectionString": "{DATABASE_URL}",
+    "graphql": true,
+    "openapi": true
+  },
+  "watch": {
+    "ignore": [
+      "*.sqlite",
+      "*.sqlite-journal"
+    ]
+  },
+  "migrations": {
+    "dir": "migrations"
+  },
+  "plugins": {
+    "paths": [
+      "plugin.ts"
+    ],
+    "typescript": {
+      "flags": ["-b"]
+    }
+  },
+  "types": {
+    "autogenerate": true
+  }
+}

package/fixtures/typescript-custom-flags/services/movies/plugin.ts

@@ -0,0 +1,5 @@
+/// <reference path="./global.d.ts" />
+import { FastifyInstance } from 'fastify'
+
+export default async function (app: FastifyInstance) {
+}

package/fixtures/typescript-custom-flags/services/movies/tsconfig.json

@@ -0,0 +1,21 @@
+{
+  "compilerOptions": {
+    "module": "commonjs",
+    "esModuleInterop": true,
+    "target": "es2019",
+    "sourceMap": true,
+    "pretty": true,
+    "noEmitOnError": true,
+    "outDir": "dist"
+  },
+  "watchOptions": {
+    "watchFile": "fixedPollingInterval",
+    "watchDirectory": "fixedPollingInterval",
+    "fallbackPolling": "dynamicPriority",
+    "synchronousWatchDirectory": true,
+    "excludeDirectories": [
+      "**/node_modules",
+      "dist"
+    ]
+  }
+}

package/fixtures/typescript-custom-flags/services/movies/types/Movie.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Movie
+ * A Movie
+ */
+declare interface Movie {
+    id?: number;
+    title: string;
+}
+export { Movie };

package/fixtures/typescript-custom-flags/services/movies/types/index.d.ts

@@ -0,0 +1,7 @@
+import { Movie } from './Movie'
+  
+  interface EntityTypes  {
+    Movie:Movie
+  }
+  
+  export { EntityTypes ,Movie }

package/fixtures/typescript-custom-flags/services/titles/client/client.d.ts

@@ -0,0 +1,141 @@
+import { FastifyPluginAsync } from 'fastify'
+
+interface GetMoviesRequest {
+  'limit'?: number;
+  'offset'?: number;
+  'totalCount'?: boolean;
+  'fields'?: Array<string>;
+  'where.id.eq'?: number;
+  'where.id.neq'?: number;
+  'where.id.gt'?: number;
+  'where.id.gte'?: number;
+  'where.id.lt'?: number;
+  'where.id.lte'?: number;
+  'where.id.like'?: number;
+  'where.id.in'?: string;
+  'where.id.nin'?: string;
+  'where.title.eq'?: string;
+  'where.title.neq'?: string;
+  'where.title.gt'?: string;
+  'where.title.gte'?: string;
+  'where.title.lt'?: string;
+  'where.title.lte'?: string;
+  'where.title.like'?: string;
+  'where.title.in'?: string;
+  'where.title.nin'?: string;
+  'where.or'?: Array<string>;
+  'orderby.id'?: string;
+  'orderby.title'?: string;
+}
+
+interface GetMoviesResponseOK {
+  'id'?: number;
+  'title': string;
+}
+
+interface CreateMovieRequest {
+  'id'?: number;
+  'title': string;
+}
+
+interface CreateMovieResponseOK {
+  'id'?: number;
+  'title': string;
+}
+
+interface UpdateMoviesRequest {
+  'fields'?: Array<string>;
+  'where.id.eq'?: number;
+  'where.id.neq'?: number;
+  'where.id.gt'?: number;
+  'where.id.gte'?: number;
+  'where.id.lt'?: number;
+  'where.id.lte'?: number;
+  'where.id.like'?: number;
+  'where.id.in'?: string;
+  'where.id.nin'?: string;
+  'where.title.eq'?: string;
+  'where.title.neq'?: string;
+  'where.title.gt'?: string;
+  'where.title.gte'?: string;
+  'where.title.lt'?: string;
+  'where.title.lte'?: string;
+  'where.title.like'?: string;
+  'where.title.in'?: string;
+  'where.title.nin'?: string;
+  'where.or'?: Array<string>;
+  'id'?: number;
+  'title': string;
+}
+
+interface UpdateMoviesResponseOK {
+  'id'?: number;
+  'title': string;
+}
+
+interface GetMovieByIdRequest {
+  'fields'?: Array<string>;
+  'id': number;
+}
+
+interface GetMovieByIdResponseOK {
+  'id'?: number;
+  'title': string;
+}
+
+interface UpdateMovieRequest {
+  'fields'?: Array<string>;
+  'id': number;
+  'title': string;
+}
+
+interface UpdateMovieResponseOK {
+  'id'?: number;
+  'title': string;
+}
+
+interface DeleteMoviesRequest {
+  'fields'?: Array<string>;
+  'id': number;
+}
+
+interface DeleteMoviesResponseOK {
+  'id'?: number;
+  'title': string;
+}
+
+interface Client {
+  getMovies(req: GetMoviesRequest): Promise<Array<GetMoviesResponseOK>>;
+  createMovie(req: CreateMovieRequest): Promise<CreateMovieResponseOK>;
+  updateMovies(req: UpdateMoviesRequest): Promise<Array<UpdateMoviesResponseOK>>;
+  getMovieById(req: GetMovieByIdRequest): Promise<GetMovieByIdResponseOK>;
+  updateMovie(req: UpdateMovieRequest): Promise<UpdateMovieResponseOK>;
+  deleteMovies(req: DeleteMoviesRequest): Promise<DeleteMoviesResponseOK>;
+}
+
+type ClientPlugin = FastifyPluginAsync<NonNullable<client.ClientOptions>>
+
+declare module 'fastify' {
+  interface ConfigureClient {
+    getHeaders(req: FastifyRequest, reply: FastifyReply): Promise<Record<string,string>>;
+  }
+  interface FastifyInstance {
+    'client': Client;
+    configureClient(opts: ConfigureClient): unknown
+  }
+
+  interface FastifyRequest {
+    'client': Client;
+  }
+}
+
+declare namespace client {
+  export interface ClientOptions {
+    url: string
+  }
+  export const client: ClientPlugin;
+  export { client as default };
+}
+
+declare function client(...params: Parameters<ClientPlugin>): ReturnType<ClientPlugin>;
+export = client;

package/fixtures/typescript-custom-flags/services/titles/client/client.openapi.json

@@ -0,0 +1,630 @@
+{
+  "openapi": "3.0.3",
+  "info": {
+    "title": "Platformatic DB",
+    "description": "Exposing a SQL database as REST",
+    "version": "1.0.0"
+  },
+  "components": {
+    "schemas": {
+      "Movie": {
+        "title": "Movie",
+        "description": "A Movie",
+        "type": "object",
+        "properties": {
+          "id": {
+            "type": "integer"
+          },
+          "title": {
+            "type": "string"
+          }
+        },
+        "required": [
+          "title"
+        ]
+      }
+    }
+  },
+  "paths": {
+    "/movies/": {
+      "get": {
+        "operationId": "getMovies",
+        "parameters": [
+          {
+            "schema": {
+              "type": "integer"
+            },
+            "in": "query",
+            "name": "limit",
+            "required": false,
+            "description": "Limit will be applied by default if not passed. If the provided value exceeds the maximum allowed value a validation error will be thrown"
+          },
+          {
+            "schema": {
+              "type": "integer"
+            },
+            "in": "query",
+            "name": "offset",
+            "required": false
+          },
+          {
+            "schema": {
+              "type": "boolean",
+              "default": false
+            },
+            "in": "query",
+            "name": "totalCount",
+            "required": false
+          },
+          {
+            "schema": {
+              "type": "array",
+              "items": {
+                "type": "string",
+                "enum": [
+                  "id",
+                  "title"
+                ]
+              }
+            },
+            "in": "query",
+            "name": "fields",
+            "required": false
+          },
+          {
+            "schema": {
+              "type": "integer"
+            },
+            "in": "query",
+            "name": "where.id.eq",
+            "required": false
+          },
+          {
+            "schema": {
+              "type": "integer"
+            },
+            "in": "query",
+            "name": "where.id.neq",
+            "required": false
+          },
+          {
+            "schema": {
+              "type": "integer"
+            },
+            "in": "query",
+            "name": "where.id.gt",
+            "required": false
+          },
+          {
+            "schema": {
+              "type": "integer"
+            },
+            "in": "query",
+            "name": "where.id.gte",
+            "required": false
+          },
+          {
+            "schema": {
+              "type": "integer"
+            },
+            "in": "query",
+            "name": "where.id.lt",
+            "required": false
+          },
+          {
+            "schema": {
+              "type": "integer"
+            },
+            "in": "query",
+            "name": "where.id.lte",
+            "required": false
+          },
+          {
+            "schema": {
+              "type": "integer"
+            },
+            "in": "query",
+            "name": "where.id.like",
+            "required": false
+          },
+          {
+            "schema": {
+              "type": "string"
+            },
+            "in": "query",
+            "name": "where.id.in",
+            "required": false
+          },
+          {
+            "schema": {
+              "type": "string"
+            },
+            "in": "query",
+            "name": "where.id.nin",
+            "required": false
+          },
+          {
+            "schema": {
+              "type": "string"
+            },
+            "in": "query",
+            "name": "where.title.eq",
+            "required": false
+          },
+          {
+            "schema": {
+              "type": "string"
+            },
+            "in": "query",
+            "name": "where.title.neq",
+            "required": false
+          },
+          {
+            "schema": {
+              "type": "string"
+            },
+            "in": "query",
+            "name": "where.title.gt",
+            "required": false
+          },
+          {
+            "schema": {
+              "type": "string"
+            },
+            "in": "query",
+            "name": "where.title.gte",
+            "required": false
+          },
+          {
+            "schema": {
+              "type": "string"
+            },
+            "in": "query",
+            "name": "where.title.lt",
+            "required": false
+          },
+          {
+            "schema": {
+              "type": "string"
+            },
+            "in": "query",
+            "name": "where.title.lte",
+            "required": false
+          },
+          {
+            "schema": {
+              "type": "string"
+            },
+            "in": "query",
+            "name": "where.title.like",
+            "required": false
+          },
+          {
+            "schema": {
+              "type": "string"
+            },
+            "in": "query",
+            "name": "where.title.in",
+            "required": false
+          },
+          {
+            "schema": {
+              "type": "string"
+            },
+            "in": "query",
+            "name": "where.title.nin",
+            "required": false
+          },
+          {
+            "schema": {
+              "type": "array",
+              "items": {
+                "type": "string"
+              }
+            },
+            "in": "query",
+            "name": "where.or",
+            "required": false
+          },
+          {
+            "schema": {
+              "type": "string",
+              "enum": [
+                "asc",
+                "desc"
+              ]
+            },
+            "in": "query",
+            "name": "orderby.id",
+            "required": false
+          },
+          {
+            "schema": {
+              "type": "string",
+              "enum": [
+                "asc",
+                "desc"
+              ]
+            },
+            "in": "query",
+            "name": "orderby.title",
+            "required": false
+          }
+        ],
+        "responses": {
+          "200": {
+            "description": "Default Response",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "type": "array",
+                  "items": {
+                    "$ref": "#/components/schemas/Movie"
+                  }
+                }
+              }
+            }
+          }
+        }
+      },
+      "post": {
+        "operationId": "createMovie",
+        "requestBody": {
+          "content": {
+            "application/json": {
+              "schema": {
+                "$ref": "#/components/schemas/Movie"
+              }
+            }
+          }
+        },
+        "responses": {
+          "200": {
+            "description": "Default Response",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/Movie"
+                }
+              }
+            },
+            "links": {}
+          }
+        }
+      },
+      "put": {
+        "operationId": "updateMovies",
+        "requestBody": {
+          "content": {
+            "application/json": {
+              "schema": {
+                "$ref": "#/components/schemas/Movie"
+              }
+            }
+          }
+        },
+        "parameters": [
+          {
+            "schema": {
+              "type": "array",
+              "items": {
+                "type": "string",
+                "enum": [
+                  "id",
+                  "title"
+                ]
+              }
+            },
+            "in": "query",
+            "name": "fields",
+            "required": false
+          },
+          {
+            "schema": {
+              "type": "integer"
+            },
+            "in": "query",
+            "name": "where.id.eq",
+            "required": false
+          },
+          {
+            "schema": {
+              "type": "integer"
+            },
+            "in": "query",
+            "name": "where.id.neq",
+            "required": false
+          },
+          {
+            "schema": {
+              "type": "integer"
+            },
+            "in": "query",
+            "name": "where.id.gt",
+            "required": false
+          },
+          {
+            "schema": {
+              "type": "integer"
+            },
+            "in": "query",
+            "name": "where.id.gte",
+            "required": false
+          },
+          {
+            "schema": {
+              "type": "integer"
+            },
+            "in": "query",
+            "name": "where.id.lt",
+            "required": false
+          },
+          {
+            "schema": {
+              "type": "integer"
+            },
+            "in": "query",
+            "name": "where.id.lte",
+            "required": false
+          },
+          {
+            "schema": {
+              "type": "integer"
+            },
+            "in": "query",
+            "name": "where.id.like",
+            "required": false
+          },
+          {
+            "schema": {
+              "type": "string"
+            },
+            "in": "query",
+            "name": "where.id.in",
+            "required": false
+          },
+          {
+            "schema": {
+              "type": "string"
+            },
+            "in": "query",
+            "name": "where.id.nin",
+            "required": false
+          },
+          {
+            "schema": {
+              "type": "string"
+            },
+            "in": "query",
+            "name": "where.title.eq",
+            "required": false
+          },
+          {
+            "schema": {
+              "type": "string"
+            },
+            "in": "query",
+            "name": "where.title.neq",
+            "required": false
+          },
+          {
+            "schema": {
+              "type": "string"
+            },
+            "in": "query",
+            "name": "where.title.gt",
+            "required": false
+          },
+          {
+            "schema": {
+              "type": "string"
+            },
+            "in": "query",
+            "name": "where.title.gte",
+            "required": false
+          },
+          {
+            "schema": {
+              "type": "string"
+            },
+            "in": "query",
+            "name": "where.title.lt",
+            "required": false
+          },
+          {
+            "schema": {
+              "type": "string"
+            },
+            "in": "query",
+            "name": "where.title.lte",
+            "required": false
+          },
+          {
+            "schema": {
+              "type": "string"
+            },
+            "in": "query",
+            "name": "where.title.like",
+            "required": false
+          },
+          {
+            "schema": {
+              "type": "string"
+            },
+            "in": "query",
+            "name": "where.title.in",
+            "required": false
+          },
+          {
+            "schema": {
+              "type": "string"
+            },
+            "in": "query",
+            "name": "where.title.nin",
+            "required": false
+          },
+          {
+            "schema": {
+              "type": "array",
+              "items": {
+                "type": "string"
+              }
+            },
+            "in": "query",
+            "name": "where.or",
+            "required": false
+          }
+        ],
+        "responses": {
+          "200": {
+            "description": "Default Response",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "type": "array",
+                  "items": {
+                    "$ref": "#/components/schemas/Movie"
+                  }
+                }
+              }
+            },
+            "links": {}
+          }
+        }
+      }
+    },
+    "/movies/{id}": {
+      "get": {
+        "operationId": "getMovieById",
+        "parameters": [
+          {
+            "schema": {
+              "type": "array",
+              "items": {
+                "type": "string",
+                "enum": [
+                  "id",
+                  "title"
+                ]
+              }
+            },
+            "in": "query",
+            "name": "fields",
+            "required": false
+          },
+          {
+            "schema": {
+              "type": "integer"
+            },
+            "in": "path",
+            "name": "id",
+            "required": true
+          }
+        ],
+        "responses": {
+          "200": {
+            "description": "Default Response",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/Movie"
+                }
+              }
+            },
+            "links": {}
+          }
+        }
+      },
+      "put": {
+        "operationId": "updateMovie",
+        "requestBody": {
+          "content": {
+            "application/json": {
+              "schema": {
+                "$ref": "#/components/schemas/Movie"
+              }
+            }
+          }
+        },
+        "parameters": [
+          {
+            "schema": {
+              "type": "array",
+              "items": {
+                "type": "string",
+                "enum": [
+                  "id",
+                  "title"
+                ]
+              }
+            },
+            "in": "query",
+            "name": "fields",
+            "required": false
+          },
+          {
+            "schema": {
+              "type": "integer"
+            },
+            "in": "path",
+            "name": "id",
+            "required": true
+          }
+        ],
+        "responses": {
+          "200": {
+            "description": "Default Response",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/Movie"
+                }
+              }
+            },
+            "links": {}
+          }
+        }
+      },
+      "delete": {
+        "operationId": "deleteMovies",
+        "parameters": [
+          {
+            "schema": {
+              "type": "array",
+              "items": {
+                "type": "string",
+                "enum": [
+                  "id",
+                  "title"
+                ]
+              }
+            },
+            "in": "query",
+            "name": "fields",
+            "required": false
+          },
+          {
+            "schema": {
+              "type": "integer"
+            },
+            "in": "path",
+            "name": "id",
+            "required": true
+          }
+        ],
+        "responses": {
+          "200": {
+            "description": "Default Response",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/Movie"
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+}

package/fixtures/typescript-custom-flags/services/titles/client/package.json

@@ -0,0 +1,4 @@
+{
+  "name": "client",
+  "types": "./client.d.ts"
+}

package/fixtures/typescript-custom-flags/services/titles/platformatic.service.json

@@ -0,0 +1,33 @@
+{
+  "$schema": "https://platformatic.dev/schemas/v0.30.0/service",
+  "server": {
+    "hostname": "{PLT_SERVER_HOSTNAME}",
+    "port": "{PORT}",
+    "logger": {
+      "level": "{PLT_SERVER_LOGGER_LEVEL}"
+    }
+  },
+  "service": {
+    "openapi": true
+  },
+  "plugins": {
+    "paths": [
+      {
+        "path": "./plugins",
+        "encapsulate": false
+      },
+      "./routes"
+    ],
+    "typescript": {
+      "flags": ["-b"]
+    }
+  },
+  "clients": [
+    {
+      "schema": "client/client.openapi.json",
+      "name": "client",
+      "type": "openapi",
+      "serviceId": "movies"
+    }
+  ]
+}

package/fixtures/typescript-custom-flags/services/titles/plugins/example.ts

@@ -0,0 +1,6 @@
+/// <reference types="@platformatic/service" />
+import { FastifyInstance, FastifyPluginOptions } from 'fastify'
+
+export default async function (fastify: FastifyInstance, opts: FastifyPluginOptions) {
+  fastify.decorate('example', 'foobar')
+}

package/fixtures/typescript-custom-flags/services/titles/routes/root.ts

@@ -0,0 +1,21 @@
+/// <reference types="@platformatic/service" />
+/// <reference types="../client" />
+import { FastifyInstance, FastifyPluginOptions } from 'fastify'
+
+declare module 'fastify' {
+  interface FastifyInstance {
+    example: string
+  }
+}
+
+export default async function (fastify: FastifyInstance, opts: FastifyPluginOptions) {
+  fastify.get('/', async (request, reply) => {
+    return { hello: fastify.example }
+  })
+
+  fastify.get('/titles', async (request, reply) => {
+    const movies = await fastify.client.getMovies({})
+    const titles = movies.map((movie) => movie.title)
+    return { titles }
+  })
+}

package/fixtures/typescript-custom-flags/services/titles/tsconfig.json

@@ -0,0 +1,21 @@
+{
+  "compilerOptions": {
+    "module": "commonjs",
+    "esModuleInterop": true,
+    "target": "es2019",
+    "sourceMap": true,
+    "pretty": true,
+    "noEmitOnError": true,
+    "outDir": "dist"
+  },
+  "watchOptions": {
+    "watchFile": "fixedPollingInterval",
+    "watchDirectory": "fixedPollingInterval",
+    "fallbackPolling": "dynamicPriority",
+    "synchronousWatchDirectory": true,
+    "excludeDirectories": [
+      "**/node_modules",
+      "dist"
+    ]
+  }
+}

package/index.js

@@ -4,6 +4,7 @@ const { platformaticRuntime } = require('./lib/config')
 const { start } = require('./lib/start')
 const unifiedApi = require('./lib/unified-api')
 const RuntimeApi = require('./lib/api')
+const { compile } = require('./lib/compile')
 
 module.exports.buildServer = buildServer
 module.exports.platformaticRuntime = platformaticRuntime
@@ -11,3 +12,4 @@ module.exports.schema = platformaticRuntime.schema
 module.exports.RuntimeApi = RuntimeApi
 module.exports.start = start
 module.exports.unifiedApi = unifiedApi
+module.exports.compile = compile

package/lib/app.js

@@ -167,13 +167,14 @@ class PlatformaticApp {
             const parts = key.split('.')
             let next = configManager.current
             let obj
+            let i
 
-            for (let i = 0; next !== undefined && i < parts.length; ++i) {
+            for (i = 0; next !== undefined && i < parts.length; ++i) {
               obj = next
               next = obj[parts[i]]
             }
 
-            if (next !== undefined) {
+            if (i === parts.length) {
               obj[parts.at(-1)] = value
             }
           })

package/lib/compile.js

@@ -1,43 +1,50 @@
 'use strict'
 
-const { loadConfig, tsCompiler } = require('@platformatic/service')
-const { access } = require('node:fs/promises')
-const { join } = require('path')
+const { tsCompiler } = require('@platformatic/service')
+const { loadConfig } = require('./unified-api')
+const { dirname } = require('node:path')
+
 const pino = require('pino')
 const pretty = require('pino-pretty')
 const { isatty } = require('node:tty')
 
-const { platformaticRuntime } = require('./config')
-
-async function compile (argv) {
-  const { configManager } = await loadConfig({}, argv, platformaticRuntime, {
+async function compile (argv, logger) {
+  const { configManager, configType } = await loadConfig({}, argv, undefined, {
     watch: false
   })
 
-  let stream
+  /* c8 ignore next */
+  if (!logger) {
+    let stream
+
+    if (isatty(process.stdout.fd)) {
+      stream = pretty({
+        translateTime: 'SYS:HH:MM:ss',
+        ignore: 'hostname,pid'
+      })
+    }
 
-  /* c8 ignore next 6 */
-  if (isatty(process.stdout.fd)) {
-    stream = pretty({
-      translateTime: 'SYS:HH:MM:ss',
-      ignore: 'hostname,pid'
-    })
+    logger = pino(stream)
   }
 
-  const logger = pino(stream)
+  let compiled = false
 
-  for (const service of configManager.current.services) {
-    const tsconfig = join(service.path, 'tsconfig.json')
+  if (configType === 'runtime') {
+    for (const service of configManager.current.services) {
+      const childLogger = logger.child({ name: service.id })
 
-    try {
-      await access(tsconfig)
-    } catch {
-      logger.trace(`No tsconfig.json found in ${service.path}, skipping...`)
-      continue
-    }
+      const serviceConfig = await loadConfig({}, argv, undefined, {
+        watch: false
+      })
 
-    await tsCompiler.compile(service.path, {}, logger.child({ name: service.id }))
+      const serviceWasCompiled = await tsCompiler.compile(service.path, serviceConfig.config, childLogger)
+      compiled ||= serviceWasCompiled
+    }
+  } else {
+    compiled = await tsCompiler.compile(dirname(configManager.fullPath), configManager.current, logger)
   }
+
+  return compiled
 }
 
 module.exports.compile = compile

package/lib/unified-api.js

@@ -135,7 +135,12 @@ async function _loadConfig (minimistConfig, args, configType, overrides) {
     configType = await getConfigType(args)
   }
 
-  return loadConfig(minimistConfig, args, getApp(configType), overrides)
+  const app = getApp(configType)
+  const res = await loadConfig(minimistConfig, args, app, overrides)
+  res.configType = configType
+  res.app = app
+
+  return res
 }
 
 async function _start (args) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@platformatic/runtime",
-  "version": "0.30.0",
+  "version": "0.31.0",
   "description": "",
   "main": "index.js",
   "bin": {
@@ -24,8 +24,8 @@
     "standard": "^17.1.0",
     "tsd": "^0.28.1",
     "typescript": "^5.1.6",
-    "@platformatic/sql-mapper": "0.30.0",
-    "@platformatic/sql-graphql": "0.30.0"
+    "@platformatic/sql-mapper": "0.31.0",
+    "@platformatic/sql-graphql": "0.31.0"
   },
   "dependencies": {
     "@hapi/topo": "^6.0.2",
@@ -40,11 +40,11 @@
     "pino": "^8.14.1",
     "pino-pretty": "^10.0.0",
     "undici": "^5.22.1",
-    "@platformatic/composer": "0.30.0",
-    "@platformatic/config": "0.30.0",
-    "@platformatic/db": "0.30.0",
-    "@platformatic/service": "0.30.0",
-    "@platformatic/utils": "0.30.0"
+    "@platformatic/composer": "0.31.0",
+    "@platformatic/config": "0.31.0",
+    "@platformatic/db": "0.31.0",
+    "@platformatic/service": "0.31.0",
+    "@platformatic/utils": "0.31.0"
   },
   "standard": {
     "ignore": [

package/runtime.mjs

@@ -7,7 +7,9 @@ import isMain from 'es-main'
 import helpMe from 'help-me'
 import parseArgs from 'minimist'
 import { start } from './lib/start.js'
-import { compile } from './lib/compile.js'
+import { compile as compileCmd } from './lib/compile.js'
+
+export const compile = compileCmd
 
 const help = helpMe({
   dir: join(import.meta.url, 'help'),

package/test/app.test.js

@@ -251,7 +251,8 @@ test('supports configuration overrides', async (t) => {
     const { logger } = getLoggerAndStream()
     config._configOverrides = new Map([
       ['server.keepAliveTimeout', 1],
-      ['server.port', 0]
+      ['server.port', 0],
+      ['server.pluginTimeout', 99]
     ])
     const app = new PlatformaticApp(config, null, logger)
 
@@ -265,6 +266,7 @@ test('supports configuration overrides', async (t) => {
 
     await app.start()
     assert.strictEqual(app.config.configManager.current.server.keepAliveTimeout, 1)
+    assert.strictEqual(app.config.configManager.current.server.pluginTimeout, 99)
   })
 })
 

package/test/cli/compile.test.mjs

@@ -14,20 +14,8 @@ try {
 } catch {
 }
 
-test('compile without tsconfigs', async () => {
-  const config = join(import.meta.url, '..', '..', 'fixtures', 'configs', 'monorepo.json')
-  await execa(cliPath, ['compile', '-c', config])
-})
-
-test('compile with tsconfig', async (t) => {
-  const tmpDir = await mkdtemp(path.join(base, 'test-runtime-compile-'))
-  const prev = process.cwd()
-  process.chdir(tmpDir)
-  t.after(() => {
-    process.chdir(prev)
-  })
-
-  t.after(async () => {
+function delDir (tmpDir) {
+  return async function () {
     // We give up after 10s.
     // This is because on Windows, it's very hard to delete files if the file
     // system is not collaborating.
@@ -42,8 +30,24 @@ test('compile with tsconfig', async (t) => {
         }
       }
     }
+  }
+}
+
+test('compile without tsconfigs', async () => {
+  const config = join(import.meta.url, '..', '..', 'fixtures', 'configs', 'monorepo.json')
+  await execa(cliPath, ['compile', '-c', config])
+})
+
+test('compile with tsconfig', async (t) => {
+  const tmpDir = await mkdtemp(path.join(base, 'test-runtime-compile-'))
+  const prev = process.cwd()
+  process.chdir(tmpDir)
+  t.after(() => {
+    process.chdir(prev)
   })
 
+  t.after(delDir(tmpDir))
+
   const folder = join(import.meta.url, '..', '..', 'fixtures', 'typescript')
   await cp(folder, tmpDir, { recursive: true })
 
@@ -63,3 +67,58 @@ test('compile with tsconfig', async (t) => {
     assert.deepStrictEqual(lines[i].msg, expected[i].msg)
   }
 })
+
+test('compile with tsconfig custom flags', async (t) => {
+  const tmpDir = await mkdtemp(path.join(base, 'test-runtime-compile-'))
+  const prev = process.cwd()
+  process.chdir(tmpDir)
+  t.after(() => {
+    process.chdir(prev)
+  })
+
+  t.after(delDir(tmpDir))
+
+  const folder = join(import.meta.url, '..', '..', 'fixtures', 'typescript-custom-flags')
+  await cp(folder, tmpDir, { recursive: true })
+
+  const { stdout } = await execa(cliPath, ['compile'])
+
+  const lines = stdout.split('\n').map(JSON.parse)
+  const expected = [{
+    name: 'movies',
+    msg: 'Typescript compilation completed successfully.'
+  }, {
+    name: 'titles',
+    msg: 'Typescript compilation completed successfully.'
+  }]
+
+  for (let i = 0; i < expected.length; i++) {
+    assert.deepStrictEqual(lines[i].name, expected[i].name)
+    assert.deepStrictEqual(lines[i].msg, expected[i].msg)
+  }
+})
+
+test('compile single service', async (t) => {
+  const tmpDir = await mkdtemp(path.join(base, 'test-runtime-compile-'))
+  const prev = process.cwd()
+  process.chdir(tmpDir)
+  t.after(() => {
+    process.chdir(prev)
+  })
+
+  t.after(delDir(tmpDir))
+
+  const folder = join(import.meta.url, '..', '..', 'fixtures', 'typescript', 'services', 'movies')
+  await cp(folder, tmpDir, { recursive: true })
+
+  const { stdout } = await execa(cliPath, ['compile'])
+
+  const lines = stdout.split('\n').map(JSON.parse)
+  const expected = [{
+    msg: 'Typescript compilation completed successfully.'
+  }]
+
+  for (let i = 0; i < expected.length; i++) {
+    assert.deepStrictEqual(lines[i].msg, expected[i].msg)
+  }
+})