@nestledjs/api 0.0.1

package/src/workspace-setup/lib/helpers.ts

@@ -0,0 +1,142 @@
+import { execSync } from 'child_process'
+import { existsSync, readFileSync, writeFileSync } from 'fs'
+import { basename } from 'path'
+import { Client } from 'pg'
+
+export const MAX_RETRIES = 30
+export const WORKSPACE_NAME = basename(process.cwd())
+export const DATABASE_URL = process.env.DATABASE_URL
+export const DOCKER_COMPOSE_FILE = '.dev/docker-compose.yml'
+
+export function log(...msg) {
+  console.log(`[${WORKSPACE_NAME}]`, ...msg)
+}
+
+export async function connectToPostgres(url: string): Promise<Client> {
+  const client = new Client(url)
+  await client.connect()
+  return client
+}
+
+export async function canConnect(url: string): Promise<boolean> {
+  try {
+    await connectToPostgres(url)
+    log('Connected to Postgres')
+    return true
+  } catch {
+    return false
+  }
+}
+
+export function ensureDockerIsRunning() {
+  try {
+    execSync('docker ps', { stdio: 'ignore' })
+    log('Docker is Up')
+    return true
+  } catch {
+    throw new Error(`Make sure Docker is running, then run this again`)
+  }
+}
+
+export function isDockerComposeRunning(): boolean {
+  try {
+    const res = execSync(`docker compose -f ${DOCKER_COMPOSE_FILE} top`, {
+      stdio: ['inherit', 'inherit'],
+    })
+
+    if (res) {
+      log('Docker Compose is Running')
+      return true
+    }
+    return false
+  } catch {
+    return false
+  }
+}
+
+export async function ensureDockerComposeIsRunning() {
+  const isRunning = isDockerComposeRunning()
+  if (isRunning) {
+    return true
+  }
+
+  try {
+    execSync(`docker compose -f ${DOCKER_COMPOSE_FILE} up -d`, { stdio: 'ignore' })
+    await waitForConnection()
+    log('Docker Compose Started')
+  } catch {
+    throw new Error(`Make sure Docker Compose is running`)
+  }
+}
+
+export function ensureDotEnv() {
+  try {
+    if (!existsSync('.env')) {
+      writeFileSync('.env', readFileSync('.env.example'))
+      log('.env created (copied from .env.example)')
+    } else {
+      log('.env exists')
+    }
+  } catch {
+    throw new Error(`Error creating or reading.env file`)
+  }
+}
+
+export function runPrismaSetup() {
+  try {
+    execSync('pnpm prisma:apply', { stdio: 'ignore' })
+    log('Prisma Setup is Done')
+    return true
+  } catch {
+    throw new Error(`There was an issue running 'pnpm prisma:apply'`)
+  }
+}
+
+export function runPrismaSeed() {
+  try {
+    execSync('npx prisma db seed -- --confirm --timeout 0', { stdio: 'inherit' })
+    log('Prisma Seed is Done')
+    return true
+  } catch (e) {
+    console.error('Prisma Seed Error:', e.message)
+    throw new Error(`There was an issue running 'pnpm prisma:seed': ${e.message}`)
+  }
+}
+
+export function runGraphQLTypeGeneration() {
+  try {
+    execSync('pnpm generate:models', { stdio: 'inherit' })
+    log('GraphQL types generation is done')
+    return true
+  } catch (e) {
+    console.error('GraphQL types generation error:', e.message)
+    throw new Error(`There was an issue running 'pnpm generate:models': ${e.message}`)
+  }
+}
+
+export const sleep = (ms = 1000) => new Promise((resolve) => setTimeout(resolve, ms))
+
+function waitForConnection(): Promise<void> {
+  log('Waiting for Postgres to connect')
+  return new Promise((resolve, reject) => {
+    let count = 0
+
+    function tryConnect() {
+      if (count >= MAX_RETRIES) {
+        reject()
+        return
+      }
+
+      canConnect(DATABASE_URL).then((isConnected) => {
+        if (isConnected) {
+          resolve()
+        } else {
+          count++
+          sleep().then(tryConnect)
+        }
+      })
+    }
+
+    tryConnect()
+  })
+}

package/src/workspace-setup/schema.d.ts

@@ -0,0 +1,3 @@
+export interface WorkspaceSetupGeneratorSchema {
+  name: string
+}

package/src/workspace-setup/schema.json

@@ -0,0 +1,7 @@
+{
+  "cli": "nx",
+  "id": "workspace-setup",
+  "type": "object",
+  "properties": {},
+  "required": []
+}

package/tsconfig.json

@@ -0,0 +1,16 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "module": "NodeNext"
+  },
+  "files": [],
+  "include": [],
+  "references": [
+    {
+      "path": "./tsconfig.lib.json"
+    },
+    {
+      "path": "./tsconfig.spec.json"
+    }
+  ]
+}

package/tsconfig.lib.json

@@ -0,0 +1,23 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "outDir": "../../dist/out-tsc",
+    "declaration": true,
+    "types": ["node"]
+  },
+  "include": ["src/**/*.ts"],
+  "exclude": [
+    "vite.config.mts",
+    "vite.config.mts",
+    "vitest.config.ts",
+    "vitest.config.mts",
+    "src/**/*.test.ts",
+    "src/**/*.spec.ts",
+    "src/**/*.test.tsx",
+    "src/**/*.spec.tsx",
+    "src/**/*.test.js",
+    "src/**/*.spec.js",
+    "src/**/*.test.jsx",
+    "src/**/*.spec.jsx"
+  ]
+}

package/tsconfig.spec.json

@@ -0,0 +1,22 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "outDir": "../../dist/out-tsc",
+    "types": ["vitest/globals", "vitest/importMeta", "vite/client", "node", "vitest"]
+  },
+  "include": [
+      "vite.config.mts",
+    "vite.config.mts",
+    "vitest.config.ts",
+    "vitest.config.mts",
+    "src/**/*.test.ts",
+    "src/**/*.spec.ts",
+    "src/**/*.test.tsx",
+    "src/**/*.spec.tsx",
+    "src/**/*.test.js",
+    "src/**/*.spec.js",
+    "src/**/*.test.jsx",
+    "src/**/*.spec.jsx",
+    "src/**/*.d.ts"
+  ]
+}

package/vite.config.mts

@@ -0,0 +1,37 @@
+/// <reference types="vitest" />
+import { defineConfig } from 'vite'
+import { nxViteTsPaths } from '@nx/vite/plugins/nx-tsconfig-paths.plugin'
+import { nxCopyAssetsPlugin } from '@nx/vite/plugins/nx-copy-assets.plugin'
+import path from 'path'
+
+export default defineConfig(() => ({
+  root: __dirname,
+  cacheDir: '../../node_modules/.vite/generators/api',
+  plugins: [nxCopyAssetsPlugin(['*.md'])],
+  resolve: {
+    alias: {
+      '@nestledjs/utils': path.resolve(__dirname, '../../dist/generators/utils/src/index.js'),
+    },
+  },
+  // Uncomment this if you are using workers.
+  // worker: {
+  //  plugins: [ nxViteTsPaths() ],
+  // },
+  test: {
+    globals: true,
+    environment: 'node',
+    include: ['src/**/*.{test,spec}.{js,mjs,cjs,ts,mts,cts,jsx,tsx}'],
+    pool: 'threads',
+    poolOptions: {
+      forks: {
+        singleFork: true,
+      },
+    },
+    watch: false,
+    reporters: ['default'],
+    coverage: {
+      reportsDirectory: '../../coverage/generators/api',
+      provider: 'v8' as const,
+    },
+  },
+}))