@platformatic/composer 3.4.1 → 3.5.1

package/scripts/schema.js

@@ -0,0 +1,12 @@
+#! /usr/bin/env node
+
+import { readFile, writeFile } from 'node:fs/promises'
+import { resolve } from 'node:path'
+
+const gatewaySchema = JSON.parse(await readFile(resolve(import.meta.dirname, '../../gateway/schema.json'), 'utf8'))
+gatewaySchema.$id = gatewaySchema.$id.replace('@platformatic/gateway', '@platformatic/composer')
+gatewaySchema.title = gatewaySchema.title.replace('Platformatic Gateway', 'Platformatic Composer')
+gatewaySchema.properties.composer = gatewaySchema.properties.gateway
+delete gatewaySchema.properties.gateway
+
+await writeFile(resolve(import.meta.dirname, '../schema.json'), JSON.stringify(gatewaySchema, null, 2), 'utf8')

package/.c8rc

@@ -1,6 +0,0 @@
-{
-  "exclude": [
-    "fixtures/*",
-    "test/*"
-  ]
-}

package/composer.mjs

@@ -1,54 +0,0 @@
-#! /usr/bin/env node
-
-import { readFile } from 'fs/promises'
-
-import commist from 'commist'
-import parseArgs from 'minimist'
-import isMain from 'es-main'
-import helpMe from 'help-me'
-import { join } from 'desm'
-import { start } from '@platformatic/service'
-import { printAndExitLoadConfigError } from '@platformatic/config'
-
-import { fetchOpenApiSchemas } from './lib/openapi-fetch-schemas.mjs'
-import { platformaticComposer } from './index.js'
-import { createComposer } from './lib/create.mjs'
-const help = helpMe({
-  dir: join(import.meta.url, 'help'),
-  // the default
-  ext: '.txt',
-})
-
-const program = commist({ maxDistance: 2 })
-
-program.register('start', (argv) => {
-  start(platformaticComposer, argv).catch(printAndExitLoadConfigError)
-})
-program.register('openapi schemas fetch', (argv) => {
-  return fetchOpenApiSchemas(argv).catch(printAndExitLoadConfigError)
-})
-program.register('create', createComposer)
-
-export async function runComposer (argv) {
-  const args = parseArgs(argv, {
-    alias: {
-      v: 'version',
-    },
-  })
-
-  if (args.version) {
-    console.log('v' + JSON.parse(await readFile(join(import.meta.url, 'package.json'), 'utf-8')).version)
-    process.exit(0)
-  }
-
-  const output = await program.parseAsync(argv)
-
-  return {
-    output,
-    help,
-  }
-}
-
-if (isMain(import.meta)) {
-  await runComposer(process.argv.splice(2))
-}

package/help/create.txt

@@ -1,11 +0,0 @@
-Creates a new Platformatic Composer application.
-
-Options are
-
-* `dir <string>` - the directory where to create the project (Default: `process.cwd() + 'platformatic-composer'`)
-* `port <string>` - the port where the application will listen (Default: `3042`)
-* `hostname <string>` - the hostname where the application will listen (Default: `0.0.0.0`)
-* `git <boolean>` - Init the git repository (Default: `true`)
-* `typescript <boolean>` - Use Typescript (Default: `false`)
-* `install <boolean>` - Run or not `npm install` after creating the files (Default: `true`)
-* `plugin <boolean>` - Creates a sample plugin and tests (Default: `true`)

package/help/help.txt

@@ -1,7 +0,0 @@
-Available commands:
-
-* `create` - creates a new Platformatic Composer application.
-* `help` - show this help message.
-* `help <command>` - shows more information about a command.
-* `start` - start the server.
-* `openapi schemas fetch` - fetch OpenAPI schemas from services.

package/help/openapi schemas fetch.txt

@@ -1,9 +0,0 @@
-Fetch OpenAPI schemas from remote services to use in your Platformatic project.
-
-``` bash
-  $ platformatic composer openapi schemas fetch
-```
-
-It will fetch all the schemas from the remote services and store them by path
-set in the `platformatic.json` file. If the path is not set, it will
-skip fetching the schema.

package/help/start.txt

@@ -1,54 +0,0 @@
-Start the Platformatic Composer server with the following command:
-
-``` bash
- $ platformatic composer start
- ```
-
-You will need a configuration file. Here is an example to get you started,
-save the following as `platformatic.json`:
-
-``` json
-  {
-    "server": {
-      "hostname": "127.0.0.1",
-      "port": 0,
-      "logger": {
-        "level": "info"
-      }
-    },
-    "composer": {
-      "services": [
-        {
-          "id": "service1",
-          "origin": "http://127.0.0.1:3051",
-          "openapi": {
-            "url": "/documentation/json"
-          }
-        },
-        {
-          "id": "service2",
-          "origin": "http://127.0.0.1:3052",
-          "openapi": {
-            "file": "./schemas/service2.openapi.json"
-          }
-        }
-      ],
-      "refreshTimeout": 1000
-    }
-  }
-```
-
-By sending the SIGUSR2 signal, the server can be reloaded.
-
-Options:
-
-* `-c, --config FILE` - Specify a configuration file to use.
-
-If not specified, the configuration will be loaded from any of the following, in the current directory.
-
-* `platformatic.json`, or
-* `platformatic.yml`, or 
-* `platformatic.tml`
-
-You can find more details about the configuration format here:
-* [Platformatic Composer Configuration](https://docs.platformatic.dev/docs/composer/configuration)

package/index.test-d.ts

@@ -1,23 +0,0 @@
-import { buildServer, PlatformaticApp, PlatformaticComposerConfig } from '.'
-import ConfigManager from '@platformatic/config'
-import { expectType } from 'tsd'
-
-declare module 'fastify' {
-  interface FastifyInstance {
-    platformatic: PlatformaticApp<PlatformaticComposerConfig>
-  }
-}
-
-async function main (): Promise<void> {
-  // TODO this configuration is incomplete, type it fully
-  const server = await buildServer({
-    server: {
-      port: 3042,
-      host: '127.0.0.1'
-    }
-  })
-
-  expectType<ConfigManager<PlatformaticComposerConfig>>(server.platformatic.configManager)
-}
-
-main().catch(console.error)

package/lib/composer-hook.js

@@ -1,60 +0,0 @@
-'use strict'
-
-const deepClone = require('rfdc')()
-const fp = require('fastify-plugin')
-const errors = require('./errors')
-
-async function composeOpenAPI (app) {
-  const onRoutesHooks = {}
-
-  app.addHook('onRoute', (routeOptions) => {
-    if (routeOptions.schema) {
-      routeOptions.schema = deepClone(routeOptions.schema)
-    }
-
-    const method = routeOptions.method
-    const openApiPath = routeOptions.config?.openApiPath
-
-    const onRouteHooks = onRoutesHooks[openApiPath]?.[method]
-    if (Array.isArray(onRouteHooks)) {
-      for (const onRouteHook of onRouteHooks) {
-        onRouteHook(routeOptions)
-      }
-    }
-  })
-
-  let isApplicationReady = false
-  app.addHook('onReady', () => {
-    isApplicationReady = true
-  })
-
-  function addComposerOnRouteHook (openApiPath, methods, hook) {
-    /* c8 ignore next 5 */
-    if (isApplicationReady) {
-      throw new errors.FastifyInstanceIsAlreadyListeningError()
-    }
-
-    if (onRoutesHooks[openApiPath] === undefined) {
-      onRoutesHooks[openApiPath] = {}
-    }
-
-    const routeHooks = onRoutesHooks[openApiPath]
-
-    for (let method of methods) {
-      method = method.toUpperCase()
-
-      if (routeHooks[method] === undefined) {
-        routeHooks[method] = []
-      }
-      routeHooks[method].push(hook)
-    }
-  }
-
-  Object.defineProperty(app.platformatic, 'addComposerOnRouteHook', {
-    value: addComposerOnRouteHook,
-    writable: false,
-    configurable: false,
-  })
-}
-
-module.exports = fp(composeOpenAPI)

package/lib/create.mjs

@@ -1,84 +0,0 @@
-'use strict'
-import minimist from 'minimist'
-import { Generator } from './generator/composer-generator.js'
-import { join } from 'node:path'
-import { getPkgManager } from '@platformatic/utils'
-import { execa } from 'execa'
-import ora from 'ora'
-import { Table } from 'console-table-printer'
-import pino from 'pino'
-import pinoPretty from 'pino-pretty'
-
-function printAppSummary (args, logger) {
-  logger.info('Creating a Platformatic Composer app with this config: ')
-  const table = [
-    { config: 'Directory', value: args.dir },
-    { config: 'Language', value: args.typescript ? 'Typescript' : 'Javascript' },
-    { config: 'Init Git Repository', value: args.git },
-    { config: 'Install Dependencies', value: args.install },
-  ]
-
-  const p = new Table({
-    columns: [
-      { name: 'config', alignment: 'right' },
-      { name: 'value', alignment: 'left' },
-    ],
-  })
-
-  p.addRows(table)
-  p.printTable()
-}
-async function createComposer (_args) {
-  const stream = pinoPretty({
-    translateTime: 'SYS:HH:MM:ss',
-    ignore: 'hostname,pid',
-    minimumLevel: 'debug',
-    sync: true,
-  })
-
-  const logger = pino(stream)
-
-  const args = minimist(process.argv.slice(2), {
-    string: ['dir', 'port', 'hostname', 'git'],
-    boolean: ['typescript', 'install'],
-    default: {
-      dir: join(process.cwd(), 'platformatic-composer'),
-      port: 3042,
-      hostname: '0.0.0.0',
-      plugin: true,
-      typescript: false,
-      git: false,
-      install: true,
-    },
-
-  })
-
-  printAppSummary(args, logger)
-
-  const gen = new Generator({})
-  gen.setConfig({
-    port: args.port,
-    hostname: args.hostname,
-    plugin: args.plugin,
-    tests: args.plugin,
-    typescript: args.typescript,
-    initGitRepository: args.git,
-    targetDirectory: args.dir,
-  })
-
-  try {
-    await gen.run()
-    if (args.install) {
-      const pkgManager = getPkgManager()
-      const spinner = ora('Installing dependencies...').start()
-      await execa(pkgManager, ['install'], { cwd: args.dir })
-      spinner.succeed()
-    }
-
-    logger.info('Done! 🎉')
-  } catch (err) {
-    logger.error(err.message)
-  }
-}
-
-export { createComposer }

package/lib/errors.js

@@ -1,13 +0,0 @@
-'use strict'
-
-const createError = require('@fastify/error')
-
-const ERROR_PREFIX = 'PLT_COMPOSER'
-
-module.exports = {
-  FastifyInstanceIsAlreadyListeningError: createError(`${ERROR_PREFIX}_FASTIFY_INSTANCE_IS_ALREADY_LISTENING`, 'Fastify instance is already listening. Cannot call "addComposerOnRouteHook"!'),
-  FailedToFetchOpenAPISchemaError: createError(`${ERROR_PREFIX}_FAILED_TO_FETCH_OPENAPI_SCHEMA`, 'Failed to fetch OpenAPI schema from %s'),
-  ValidationErrors: createError(`${ERROR_PREFIX}_VALIDATION_ERRORS`, 'Validation errors: %s'),
-  PathAlreadyExistsError: createError(`${ERROR_PREFIX}_PATH_ALREADY_EXISTS`, 'Path "%s" already exists'),
-  CouldNotReadOpenAPIConfigError: createError(`${ERROR_PREFIX}_COULD_NOT_READ_OPENAPI_CONFIG`, 'Could not read openapi config for "%s" service'),
-}

package/lib/generator/README.md

@@ -1,30 +0,0 @@
-# Platformatic Composer API
-
-This is a generated [Platformatic Composer](https://docs.platformatic.dev/docs/composer/overview) application.
-
-## Requirements
-
-Platformatic supports macOS, Linux and Windows ([WSL](https://docs.microsoft.com/windows/wsl/) recommended).
-You'll need to have [Node.js](https://nodejs.org/) >= v18.8.0 or >= v20.6.0
-
-## Setup
-
-1. Install dependencies:
-
-```bash
-npm install
-```
-
-## Usage
-
-Run the API with:
-
-```bash
-npm start
-```
-
-### Explore
-- ⚡ The Platformatic Composer server is running at http://localhost:3042/
-- 📔 View the REST API's Swagger documentation at http://localhost:3042/documentation/
-
-

package/lib/generator/composer-generator.d.ts

@@ -1,11 +0,0 @@
-import { BaseGenerator } from "@platformatic/generators";
-import RuntimeGenerator from "../../../runtime/lib/generator/runtime-generator";
-
-export namespace ComposerGenerator {
-  export class ComposerGenerator extends BaseGenerator {
-    runtime: RuntimeGenerator
-
-    setRuntime(runtime: RuntimeGenerator): void
-  }
-  
-}

package/lib/generator/composer-generator.js

@@ -1,128 +0,0 @@
-'use strict'
-
-const { BaseGenerator } = require('@platformatic/generators')
-const { join } = require('node:path')
-const { readFile } = require('node:fs/promises')
-
-class ComposerGenerator extends BaseGenerator {
-  constructor (opts) {
-    super({
-      ...opts,
-      module: '@platformatic/composer',
-    })
-    this.runtime = null
-  }
-
-  getDefaultConfig () {
-    const defaultBaseConfig = super.getDefaultConfig()
-    return {
-      ...defaultBaseConfig,
-      plugin: false,
-      routes: false,
-      tests: false,
-    }
-  }
-
-  async _getConfigFileContents () {
-    const template = {
-      $schema: `https://schemas.platformatic.dev/@platformatic/composer/${this.platformaticVersion}.json`,
-      composer: {
-        services: [
-          {
-            id: 'example',
-            origin: `{${this.getEnvVarName('PLT_EXAMPLE_ORIGIN')}}`,
-            openapi: {
-              url: '/documentation/json',
-            },
-          },
-        ],
-        refreshTimeout: 1000,
-      },
-      watch: true,
-    }
-    if (this.runtime !== null) {
-      template.composer.services = this.runtime.services
-        .filter(serviceMeta => serviceMeta.service.module !== '@platformatic/composer')
-        .map((serviceMeta) => {
-          return {
-            id: serviceMeta.name,
-            openapi: {
-              url: '/documentation/json',
-              prefix: `/${serviceMeta.name}`,
-            },
-          }
-        })
-    }
-
-    if (this.config.plugin) {
-      template.plugins = {
-        paths: [
-          {
-            path: './plugins',
-            encapsulate: false,
-          },
-          './routes',
-        ],
-        typescript: `{${this.getEnvVarName('PLT_TYPESCRIPT')}}`,
-      }
-    }
-
-    if (!this.config.isRuntimeContext) {
-      template.server = {
-        hostname: '{PLT_SERVER_HOSTNAME}',
-        port: '{PORT}',
-        logger: {
-          level: '{PLT_SERVER_LOGGER_LEVEL}',
-        },
-      }
-    }
-
-    return template
-  }
-
-  async _beforePrepare () {
-    if (!this.config.isUpdating) {
-      if (!this.config.isRuntimeContext) {
-        this.addEnvVars({
-          PLT_SERVER_HOSTNAME: this.config.hostname,
-          PLT_SERVER_LOGGER_LEVEL: 'info',
-          PORT: 3042,
-        }, { overwrite: false, default: true })
-      }
-
-      this.addEnvVars({
-        PLT_TYPESCRIPT: this.config.typescript,
-        PLT_EXAMPLE_ORIGIN: 'http://127.0.0.1:3043',
-      }, { overwrite: false, default: true })
-
-      this.config.dependencies = {
-        '@platformatic/composer': `^${this.platformaticVersion}`,
-      }
-    }
-  }
-
-  async _afterPrepare () {
-    if (!this.config.isUpdating) {
-      const GLOBAL_TYPES_TEMPLATE = `
-import { FastifyInstance } from 'fastify'
-import { PlatformaticApp, PlatformaticComposerConfig } from '@platformatic/composer'
-
-declare module 'fastify' {
-  interface FastifyInstance {
-    platformatic: PlatformaticApp<PlatformaticComposerConfig>
-  }
-}
-`
-      this.addFile({ path: '', file: 'global.d.ts', contents: GLOBAL_TYPES_TEMPLATE })
-      this.addFile({ path: '', file: 'README.md', contents: await readFile(join(__dirname, 'README.md'), 'utf-8') })
-    }
-  }
-
-  setRuntime (runtime) {
-    this.runtime = runtime
-  }
-}
-
-module.exports = ComposerGenerator
-module.exports.ComposerGenerator = ComposerGenerator
-module.exports.Generator = ComposerGenerator

package/lib/graphql-fetch.js

@@ -1,85 +0,0 @@
-'use strict'
-
-const { compose } = require('@platformatic/graphql-composer')
-
-const placeholderSdl = 'Query { _info: String }'
-const placeholderResolvers = { Query: { _info: 'platformatic composer' } }
-
-function createSupergraph ({ sdl = null, resolvers = {} } = {}) {
-  // in case of temporary failures of subgraphs on watching, the service can restart if no subgraphs are (tempoary) available
-  if (!sdl) {
-    return {
-      sdl: placeholderSdl,
-      resolvers: placeholderResolvers,
-    }
-  }
-  return { sdl, resolvers }
-}
-
-function isSameGraphqlSchema (a, b) {
-  // TODO review
-  return a?.sdl === b?.sdl
-}
-
-function serviceToSubgraphConfig (service) {
-  if (!service.graphql) { return }
-  return {
-    name: service.graphql.name || service.id || service.origin,
-    entities: service.graphql.entities,
-    server: {
-      host: service.graphql.host || service.origin,
-      composeEndpoint: service.graphql.composeEndpoint,
-      graphqlEndpoint: service.graphql.graphqlEndpoint,
-    },
-  }
-}
-
-async function fetchGraphqlSubgraphs (services, options, app) {
-  const subgraphs = services.map(serviceToSubgraphConfig).filter(s => !!s)
-  const composer = await compose({ ...toComposerOptions(options, app), subgraphs })
-
-  return createSupergraph({
-    logger: app.log,
-    sdl: composer.toSdl(),
-    resolvers: composer.resolvers,
-  })
-}
-
-// TODO support subscriptions
-// const defaultSubscriptionsOptions = {
-//   onError: function onComposerSubscriptionsError (ctx, topic, err) {
-//     // TODO log.error({err})
-//     throw err
-//   },
-//   publish (ctx, topic, payload) {
-//     ctx.pubsub.publish({ topic, payload })
-//   },
-//   subscribe (ctx, topic) {
-//     return ctx.pubsub.subscribe(topic)
-//   },
-//   unsubscribe (ctx, topic) {
-//     ctx.pubsub.close()
-//   }
-// }
-
-function toComposerOptions (options, app) {
-  return {
-    logger: app.log,
-    defaultArgsAdapter: options?.defaultArgsAdapter,
-    addEntitiesResolvers: options?.addEntitiesResolvers,
-    entities: options?.entities,
-    onSubgraphError: (err, subgraphName) => {
-      app.log.error({ err }, 'graphql composer error on subgraph ' + subgraphName)
-
-      if (options?.onSubgraphError) {
-        try {
-          options.onSubgraphError(err, subgraphName)
-        } catch (err) {
-          app.log.error({ err }, 'running onSubgraphError')
-        }
-      }
-    },
-  }
-}
-
-module.exports = { fetchGraphqlSubgraphs, createSupergraph, isSameGraphqlSchema, serviceToSubgraphConfig }

package/lib/graphql-generator.js

@@ -1,31 +0,0 @@
-'use strict'
-
-const fp = require('fastify-plugin')
-const mercurius = require('mercurius')
-const { fetchGraphqlSubgraphs } = require('./graphql-fetch')
-
-async function composeGraphql (app, opts) {
-  if (!opts.services.some(s => s.graphql)) { return }
-
-  const services = []
-
-  for (const service of opts.services) {
-    if (!service.graphql) { continue }
-    services.push(service)
-  }
-
-  const graphqlConfig = {
-    graphiql: opts.graphql?.graphiql,
-  }
-  if (services.length > 0) {
-    const graphqlSupergraph = await fetchGraphqlSubgraphs(services, opts.graphql, app)
-    graphqlConfig.schema = graphqlSupergraph.sdl
-    graphqlConfig.resolvers = graphqlSupergraph.resolvers
-    graphqlConfig.subscription = false // TODO support subscriptions, will be !!opts.graphql.subscriptions
-    app.graphqlSupergraph = graphqlSupergraph
-  }
-
-  await app.register(mercurius, graphqlConfig)
-}
-
-module.exports = fp(composeGraphql)

package/lib/graphql.js

@@ -1,20 +0,0 @@
-'use strict'
-
-const fp = require('fastify-plugin')
-const { createSupergraph } = require('./graphql-fetch')
-
-const graphqlSupergraphSymbol = Symbol('graphqlSupergraph')
-
-async function composeGraphql (app, opts) {
-  app.decorate('graphqlSupergraph', {
-    getter () { return this[graphqlSupergraphSymbol] },
-    setter (v) { this[graphqlSupergraphSymbol] = v },
-  })
-  app.decorate('graphqlComposerOptions', {
-    getter () { return opts },
-  })
-
-  app.graphqlSupergraph = createSupergraph()
-}
-
-module.exports = fp(composeGraphql)