@spacemade/ui 0.0.1

package/scripts/crud-scaffold/src/api/index.mjs

@@ -0,0 +1,666 @@
+import { quote } from '../core/fields.mjs'
+import {
+  authOptionsForResource,
+  camel,
+  getResourceScope,
+  pascalFromRoute,
+  snakeToCamel,
+  tableName,
+} from '../core/utils.mjs'
+
+export function createModel(resource) {
+  const declarations = resource.fields
+    .map((item) => `  declare ${item.name}: ${item.tsType}`)
+    .join('\n')
+
+  const initFields = resource.fields
+    .map((item) => {
+      const lines = [
+        `${item.name}: {`,
+        `  type: ${item.dataType},`,
+        `  allowNull: ${item.allowNull ? 'true' : 'false'},`,
+      ]
+
+      if (item.defaultValue !== undefined) {
+        lines.push(`  defaultValue: ${typeof item.defaultValue === 'string' ? quote(item.defaultValue) : item.defaultValue},`)
+      }
+
+      if (item.references) {
+        lines.push(`  references: { model: ${quote(item.references)}, key: 'id' },`)
+        lines.push("  onUpdate: 'CASCADE',")
+        lines.push(`  onDelete: ${quote(item.onDelete || 'SET NULL')},`)
+      }
+
+      lines.push('},')
+      return `      ${lines.join('\n      ')}`
+    })
+    .join('\n')
+
+  return `import {
+  CreationOptional,
+  DataTypes,
+  InferAttributes,
+  InferCreationAttributes,
+  Model,
+  Sequelize,
+} from 'sequelize'
+import connection from '@lib/database/connection'
+
+export class ${resource.name} extends Model<
+  InferAttributes<${resource.name}>,
+  InferCreationAttributes<${resource.name}>
+> {
+  declare id: CreationOptional<string>
+${declarations}
+  declare created_at: CreationOptional<Date>
+  declare updated_at: CreationOptional<Date>
+}
+
+const init${resource.name} = (sequelize: Sequelize) => {
+  ${resource.name}.init(
+    {
+      id: {
+        type: DataTypes.UUID,
+        defaultValue: DataTypes.UUIDV1,
+        primaryKey: true,
+        allowNull: false,
+      },
+${initFields}
+      created_at: DataTypes.DATE,
+      updated_at: DataTypes.DATE,
+    },
+    {
+      sequelize,
+      modelName: '${resource.name}',
+      tableName: '${tableName(resource)}',
+      createdAt: 'created_at',
+      updatedAt: 'updated_at',
+    }
+  )
+
+  return ${resource.name}
+}
+
+export default init${resource.name}(connection)
+`
+}
+
+const defaultExternalModelImports = {
+  Org: '@lib/models',
+  Project: '@lib/models',
+  User: '@lib/models',
+  Product: '@lib/models',
+  ProductPlan: '@lib/models',
+  ProductVersion: '@lib/models',
+  Provider: '@lib/models',
+  Site: '@lib/models',
+  Subscription: '@lib/models',
+}
+
+export function createBackendModelIndex(resources, associations, title, options) {
+  const generatedModelNames = new Set(resources.map((resource) => resource.name))
+  const externalModelImports = {
+    ...defaultExternalModelImports,
+    ...(options.externalModelImports || {}),
+  }
+  const imports = resources
+    .map((resource) => `import { ${resource.name} } from './${resource.slug}.model'`)
+    .join('\n')
+
+  const externalImports = Object.entries(
+    associations.reduce((acc, item) => {
+      ;[item.source, item.target].forEach((modelName) => {
+        if (generatedModelNames.has(modelName)) return
+        const importPath = externalModelImports[modelName]
+        if (!importPath) return
+        acc[importPath] = acc[importPath] || []
+        if (!acc[importPath].includes(modelName)) acc[importPath].push(modelName)
+      })
+      return acc
+    }, {})
+  )
+    .map(([importPath, modelNames]) => `import { ${modelNames.join(', ')} } from '${importPath}'`)
+    .join('\n')
+
+  const associationLines = associations
+    .map((item) => `${item.source}.${item.method}(${item.target}, ${item.options})`)
+    .join('\n')
+
+  const exports = resources.map((resource) => `  ${resource.name},`).join('\n')
+
+  return `${imports}
+${externalImports ? `${externalImports}\n` : ''}
+
+/* =============================================================================
+ * ${title} Associations
+ * =============================================================================
+ */
+${associationLines}
+
+export {
+${exports}
+}
+`
+}
+
+const unique = (values) => [...new Set(values.filter(Boolean))]
+
+function relationImportGroups(resource, options) {
+  const groups = {}
+  for (const item of resource.fields) {
+    const validation = item.validate
+    if (!validation?.model) continue
+    const importPath = validation.importRoot || options.api.importRoot
+    groups[importPath] = groups[importPath] || []
+    groups[importPath].push(validation.model)
+  }
+
+  for (const item of resource.serviceImports || []) {
+    groups[item.importRoot] = groups[item.importRoot] || []
+    groups[item.importRoot].push(...item.models)
+  }
+
+  return Object.fromEntries(
+    Object.entries(groups).map(([importPath, modelNames]) => [
+      importPath,
+      unique(modelNames),
+    ])
+  )
+}
+
+function relationExpression(value, valueVar) {
+  if (value === '$value') return valueVar
+  return value
+}
+
+function createRelationValidationBlock(resource) {
+  const validations = resource.fields
+    .filter((item) => item.validate?.model)
+    .map((item) => {
+      const validation = item.validate
+      const valueVar = snakeToCamel(item.name)
+      const whereVar = `${valueVar}Where`
+      const recordVar = `${valueVar}Record`
+      const whereLines = validation.where
+        .map((entry) => {
+          const expression = relationExpression(entry.value, valueVar)
+          if (entry.optional) {
+            const candidateVar = `${whereVar}${entry.column.charAt(0).toUpperCase()}${snakeToCamel(entry.column).slice(1)}`
+            return `      const ${candidateVar} = ${expression}
+      if (${candidateVar}) ${whereVar}.${entry.column} = ${candidateVar}`
+          }
+          return `      ${whereVar}.${entry.column} = ${expression}`
+        })
+        .join('\n')
+
+      return `    const ${valueVar} = payload.${item.name} !== undefined ? payload.${item.name} : record?.${item.name}
+    if (${valueVar} !== undefined && ${valueVar} !== null) {
+      const ${whereVar}: Record<string, unknown> = {}
+${whereLines}
+      const ${recordVar} = await ${validation.model}.findOne({ where: ${whereVar} as any })
+      if (!(${recordVar} instanceof ${validation.model})) {
+        throw NotFoundError('${validation.message || `${validation.model} Not Found`}')
+      }
+    }`
+    })
+
+  const customValidation = resource.serviceValidate?.trim()
+  if (!validations.length && !customValidation) return ''
+
+  return `
+async function validateRelations(
+  payload: Record<string, any>,
+  scopedValues: Record<string, unknown>,
+  record?: ${resource.name}
+) {
+${validations.join('\n\n')}
+${customValidation ? `\n${customValidation}\n` : ''}
+}
+`
+}
+
+export function createService(resource, options) {
+  const scope = getResourceScope(resource, options)
+  const validators = ['isValidUUID']
+  if (resource.fields.some((item) => item.schema?.includes('DOMAIN_REGEX'))) validators.unshift('DOMAIN_REGEX')
+  if (resource.fields.some((item) => item.schema?.includes('SLUG_REGEX'))) validators.unshift('SLUG_REGEX')
+  const relationImports = relationImportGroups(resource, options)
+  const sameRootRelationModels = relationImports[options.api.importRoot] || []
+  const serviceModelNames = unique([resource.name, ...sameRootRelationModels])
+  const externalRelationImports = Object.entries(relationImports)
+    .filter(([importPath]) => importPath !== options.api.importRoot)
+    .map(([importPath, modelNames]) => `import { ${modelNames.join(', ')} } from '${importPath}'`)
+    .join('\n')
+  const relationValidationBlock = createRelationValidationBlock(resource)
+  const relationValidationCall = relationValidationBlock
+    ? '    await validateRelations(payload, scopedValues)\n\n'
+    : ''
+  const relationUpdateValidationCall = relationValidationBlock
+    ? `    await validateRelations(payload, ${scope.orgField || scope.projectField ? 'buildCreateScopeValues(req)' : '{}'}, record)\n\n`
+    : ''
+
+  const schemaFields = resource.fields
+    .filter((item) => !item.skipSchema)
+    .map((item) => `  ${item.name}: ${item.schema},`)
+    .join('\n')
+
+  const scopedFieldNames = new Set([scope.orgField, scope.projectField].filter(Boolean))
+
+  const createFields = resource.fields
+    .map((item) => {
+      if (item.isJson) return `      ${item.name}: typeof req.body?.${item.name} === 'object' ? req.body.${item.name} : null,`
+      if (item.name === scope.orgField || item.name === scope.projectField) return `      ${item.name}: scopedValues.${item.name},`
+      return `      ${item.name}: payload.${item.name},`
+    })
+    .join('\n')
+
+  const updateFields = resource.fields
+    .filter((item) => !scopedFieldNames.has(item.name))
+    .map((item) => {
+      if (item.isJson) {
+        return `      ${item.name}: Object.prototype.hasOwnProperty.call(req.body || {}, '${item.name}') ? req.body.${item.name} : undefined,`
+      }
+      return `      ${item.name}: payload.${item.name},`
+    })
+    .join('\n')
+
+  const searchFields = resource.searchFields
+    .map((item) => `      { ${item}: { [Op.like]: '%' + term + '%' } },`)
+    .join('\n')
+  const listFilterLines = (resource.listFilters || [])
+    .map((fieldName) => {
+      const camelName = snakeToCamel(fieldName)
+      return `  const ${camelName} = Array.isArray(req.query.${fieldName}) ? req.query.${fieldName}[0] : req.query.${fieldName}
+  if (typeof ${camelName} === 'string' && ${camelName}.trim()) {
+    ;(where as any).${fieldName} = ${camelName}.trim()
+  }`
+    })
+    .join('\n')
+
+  const scopeImports = [
+    scope.orgField
+      ? "import { requireActiveOrgId, type RequestWithOrg } from '@lib/middleware/with-active-org'"
+      : '',
+    scope.projectField
+      ? "import { resolveProjectScopeId, type RequestWithProject } from '@lib/middleware/with-active-project'"
+      : '',
+  ].filter(Boolean).join('\n')
+
+  const scopeWhereLines = [
+    scope.orgField ? `  where.${scope.orgField} = requireActiveOrgId(req as RequestWithOrg)` : '',
+    scope.projectField ? `  const scopedProjectId = resolveProjectScopeId(req as RequestWithProject, projectInput)` : '',
+    scope.projectField ? `  if (scopedProjectId) where.${scope.projectField} = scopedProjectId` : '',
+  ].filter(Boolean).join('\n')
+
+  const createScopeLines = [
+    scope.orgField ? `  values.${scope.orgField} = requireActiveOrgId(req as RequestWithOrg)` : '',
+    scope.projectField ? "  const scopedProjectId = resolveProjectScopeId(req as RequestWithProject, req.body?.project_id)" : '',
+    scope.projectField ? `  values.${scope.projectField} = scopedProjectId || null` : '',
+  ].filter(Boolean).join('\n')
+
+  const scopeHelpers = scope.orgField || scope.projectField
+    ? `
+function buildScopeWhere(req: NextApiRequest, projectInput?: unknown) {
+  const where: Record<string, unknown> = {}
+${scopeWhereLines}
+  return where
+}
+
+function buildCreateScopeValues(req: NextApiRequest) {
+  const values: Record<string, unknown> = {}
+${createScopeLines}
+  return values
+}
+`
+    : ''
+
+  const listScopeArgs = scope.projectField ? 'req.query.project_id' : ''
+  const scopedWhereCall = scope.orgField || scope.projectField
+    ? `buildScopeWhere(req${listScopeArgs ? `, ${listScopeArgs}` : ''})`
+    : '{}'
+  const byIdWhere = scope.orgField || scope.projectField
+    ? '{ id, ...buildScopeWhere(req) }'
+    : '{ id }'
+  const getOneQuery = scope.orgField || scope.projectField
+    ? `${resource.name}.findOne({ where: ${byIdWhere} as any })`
+    : `${resource.name}.findByPk(id)`
+  const createScopeValuesExpression = scope.orgField || scope.projectField
+    ? 'buildCreateScopeValues(req)'
+    : '{}'
+
+  return `import type { NextApiRequest } from 'next'
+import { InferAttributes, Op, WhereOptions } from 'sequelize'
+import { ${serviceModelNames.join(', ')} } from '${options.api.importRoot}/models'
+${externalRelationImports ? `${externalRelationImports}\n` : ''}
+import { InvalidDataError, NotFoundError } from '@lib/utils/api-errors'
+import { cleanEmptyValues, transformQueryToOptions } from '@lib/utils/data-transform'
+import { GeneratePagingResponse } from '@lib/utils/paging-response'
+import { ${validators.join(', ')} } from '@lib/utils/string-regex-validation'
+import {
+  FieldValidationSchema,
+  validateAndSanitize,
+} from '@lib/utils/validate-payload'
+${scopeImports ? `${scopeImports}\n` : ''}
+
+const payloadSchema: FieldValidationSchema = {
+${schemaFields}
+}
+
+function requireValidId(id: unknown) {
+  if (typeof id !== 'string' || !isValidUUID(id)) {
+    throw InvalidDataError('Invalid or missing ${resource.name} ID')
+  }
+
+  return id
+}
+
+function buildWhere(req: NextApiRequest) {
+  const where = ${scopedWhereCall} as WhereOptions<InferAttributes<${resource.name}>>
+  const q = Array.isArray(req.query.q) ? req.query.q[0] : req.query.q
+  const nameLike = Array.isArray(req.query.nameLike) ? req.query.nameLike[0] : req.query.nameLike
+  const search = typeof q === 'string' && q.trim() ? q : nameLike
+
+  if (typeof search === 'string' && search.trim()) {
+    const term = search.trim()
+    ;(where as any)[Op.or] = [
+${searchFields}
+    ]
+  }
+${listFilterLines ? `\n${listFilterLines}\n` : ''}
+
+  return where
+}
+${scopeHelpers}
+${relationValidationBlock}
+
+export class ${resource.name}Service {
+  public async list(req: NextApiRequest) {
+    const limitQuery = Array.isArray(req.query.limit) ? req.query.limit[0] : req.query.limit
+    const pageQuery = Array.isArray(req.query.page) ? req.query.page[0] : req.query.page
+    const paging = transformQueryToOptions(limitQuery?.toString(), pageQuery?.toString())
+
+    const records = await ${resource.name}.findAndCountAll({
+      where: buildWhere(req),
+      order: [['created_at', 'DESC']],
+      limit: paging.limit,
+      offset: paging.offset,
+      distinct: true,
+    })
+
+    return GeneratePagingResponse(records.rows, records.count, paging.limit, paging.page, req)
+  }
+
+  public async getOne(req: NextApiRequest, idInput: unknown) {
+    const id = requireValidId(idInput)
+
+    const record = await ${getOneQuery}
+    if (!(record instanceof ${resource.name})) {
+      throw NotFoundError('${resource.name} Not Found')
+    }
+
+    return record
+  }
+
+  public async create(req: NextApiRequest) {
+    const payload = await validateAndSanitize(req.body, payloadSchema)
+    const scopedValues = ${createScopeValuesExpression}
+
+${relationValidationCall}    return ${resource.name}.create(cleanEmptyValues({
+${createFields}
+    }) as any)
+  }
+
+  public async update(req: NextApiRequest, idInput: unknown) {
+    const id = requireValidId(idInput)
+
+    const payload = await validateAndSanitize(req.body, payloadSchema, true)
+    const record = await ${getOneQuery}
+
+    if (!(record instanceof ${resource.name})) {
+      throw NotFoundError('${resource.name} Not Found')
+    }
+
+${relationUpdateValidationCall}    record.set(cleanEmptyValues({
+${updateFields}
+    }) as any)
+    await record.save({ hooks: true })
+
+    return record
+  }
+
+  public async delete(req: NextApiRequest, idInput: unknown) {
+    const id = requireValidId(idInput)
+
+    const record = await ${getOneQuery}
+    if (!(record instanceof ${resource.name})) {
+      throw NotFoundError('${resource.name} Not Found')
+    }
+
+    await record.destroy()
+
+    return {
+      success: true,
+      message: '${resource.name} deleted successfully.',
+    }
+  }
+}
+
+export const ${camel(resource.name)}Service = new ${resource.name}Service()
+`
+}
+
+export function createController(resource, options) {
+  return `import type { NextApiRequest, NextApiResponse } from 'next'
+import { StatusCodes } from 'http-status-codes'
+import {
+  ${resource.name}Service,
+  ${camel(resource.name)}Service,
+} from '${options.api.importRoot}/services/${resource.slug}.service'
+
+export function create${resource.name}Controller(service: ${resource.name}Service = ${camel(resource.name)}Service) {
+  return {
+    async list(req: NextApiRequest, res: NextApiResponse) {
+      const response = await service.list(req)
+      res.status(StatusCodes.OK).json({ ...response })
+    },
+
+    async getOne(req: NextApiRequest, res: NextApiResponse) {
+      const record = await service.getOne(req, req.query.id)
+      res.status(StatusCodes.OK).json({ ${resource.responseKey}: record })
+    },
+
+    async create(req: NextApiRequest, res: NextApiResponse) {
+      const record = await service.create(req)
+      res.status(StatusCodes.CREATED).json({ ${resource.responseKey}: record })
+    },
+
+    async update(req: NextApiRequest, res: NextApiResponse) {
+      const record = await service.update(req, req.query.id)
+      res.status(StatusCodes.OK).json({ ${resource.responseKey}: record })
+    },
+
+    async delete(req: NextApiRequest, res: NextApiResponse) {
+      const response = await service.delete(req, req.query.id)
+      res.status(StatusCodes.OK).json(response)
+    },
+  }
+}
+
+export const ${resource.name}Controller = create${resource.name}Controller()
+export default ${resource.name}Controller
+`
+}
+
+export function createCollectionActionService(action) {
+  return action.serviceSource
+}
+
+export function createCollectionActionRoute(action, options) {
+  const authOptions = action.authOptions || authOptionsForResource(action.resource, options)
+
+  return `import type { NextApiRequest, NextApiResponse } from 'next'
+import { StatusCodes } from 'http-status-codes'
+import { runGlobalMiddleware, withAuth, withErrorHandler } from '@lib/middleware'
+import { ${action.serviceInstance} } from '${options.api.importRoot}/services/${action.serviceFile}.service'
+import { throwInvalidMethodError } from '@lib/utils/invalid-method'
+import HTTPMethod from '@lib/utils/methods'
+
+const handler = async (req: NextApiRequest, res: NextApiResponse) => {
+  await runGlobalMiddleware(req, res)
+
+  switch (req.method) {
+    case HTTPMethod.${action.httpMethod || 'GET'}: {
+      await withAuth(
+        req,
+        res,
+        async () => {
+          const response = await ${action.serviceInstance}.${action.serviceMethod}(req)
+          res.status(StatusCodes.OK).json(response)
+        }${authOptions}
+      )
+      return
+    }
+    default:
+      throwInvalidMethodError(res, [HTTPMethod.${action.httpMethod || 'GET'}])
+      return
+  }
+}
+
+export default withErrorHandler(handler)
+`
+}
+
+export function createIndexRoute(resource, options) {
+  const authOptions = authOptionsForResource(resource, options)
+
+  return `import type { NextApiRequest, NextApiResponse } from 'next'
+import { runGlobalMiddleware, withAuth, withErrorHandler } from '@lib/middleware'
+import { ${resource.name}Controller } from '${options.api.importRoot}/controllers/${resource.slug}.controller'
+import { throwInvalidMethodError } from '@lib/utils/invalid-method'
+import HTTPMethod from '@lib/utils/methods'
+
+const handler = async (req: NextApiRequest, res: NextApiResponse) => {
+  await runGlobalMiddleware(req, res)
+
+  switch (req.method) {
+    case HTTPMethod.GET:
+      await withAuth(req, res, ${resource.name}Controller.list${authOptions})
+      return
+    case HTTPMethod.POST:
+      await withAuth(req, res, ${resource.name}Controller.create${authOptions})
+      return
+    default:
+      throwInvalidMethodError(res, [HTTPMethod.GET, HTTPMethod.POST])
+      return
+  }
+}
+
+export default withErrorHandler(handler)
+`
+}
+
+export function createIdRoute(resource, options) {
+  const authOptions = authOptionsForResource(resource, options)
+
+  return `import type { NextApiRequest, NextApiResponse } from 'next'
+import { runGlobalMiddleware, withAuth, withErrorHandler } from '@lib/middleware'
+import { ${resource.name}Controller } from '${options.api.importRoot}/controllers/${resource.slug}.controller'
+import { throwInvalidMethodError } from '@lib/utils/invalid-method'
+import HTTPMethod from '@lib/utils/methods'
+
+const handler = async (req: NextApiRequest, res: NextApiResponse) => {
+  await runGlobalMiddleware(req, res)
+
+  switch (req.method) {
+    case HTTPMethod.GET:
+      await withAuth(req, res, ${resource.name}Controller.getOne${authOptions})
+      return
+    case HTTPMethod.PUT:
+    case HTTPMethod.PATCH:
+      await withAuth(req, res, ${resource.name}Controller.update${authOptions})
+      return
+    case HTTPMethod.DELETE:
+      await withAuth(req, res, ${resource.name}Controller.delete${authOptions})
+      return
+    default:
+      throwInvalidMethodError(res, [
+        HTTPMethod.GET,
+        HTTPMethod.PUT,
+        HTTPMethod.PATCH,
+        HTTPMethod.DELETE,
+      ])
+      return
+  }
+}
+
+export default withErrorHandler(handler)
+`
+}
+
+export function createMigration(resource) {
+  const fields = resource.fields
+    .map((item) => {
+      const lines = [
+        `${item.name}: {`,
+        `  type: ${item.dataType},`,
+        `  allowNull: ${item.allowNull ? 'true' : 'false'},`,
+      ]
+
+      if (item.defaultValue !== undefined) {
+        lines.push(`  defaultValue: ${typeof item.defaultValue === 'string' ? quote(item.defaultValue) : item.defaultValue},`)
+      }
+
+      if (item.references) {
+        lines.push(`  references: { model: ${quote(item.references)}, key: 'id' },`)
+        lines.push("  onUpdate: 'CASCADE',")
+        lines.push(`  onDelete: ${quote(item.onDelete || 'SET NULL')},`)
+      }
+
+      lines.push('},')
+      return `      ${lines.join('\n      ')}`
+    })
+    .join('\n')
+
+  const indexes = resource.fields
+    .filter((item) => item.references || item.name === 'slug' || item.name === 'hostname' || item.name === 'status')
+    .map((item) => `    await queryInterface.addIndex('${tableName(resource)}', ['${item.name}'], {
+      name: '${tableName(resource)}_${item.name}_idx',
+    })`)
+    .join('\n\n')
+
+  return `'use strict'
+
+/** @type {import('sequelize-cli').Migration} */
+module.exports = {
+  async up(queryInterface, Sequelize) {
+    const { DataTypes } = Sequelize
+
+    await queryInterface.createTable('${tableName(resource)}', {
+      id: {
+        type: DataTypes.UUID,
+        primaryKey: true,
+        allowNull: false,
+        defaultValue: DataTypes.UUIDV1,
+      },
+${fields}
+      created_at: {
+        type: DataTypes.DATE,
+        allowNull: false,
+        defaultValue: Sequelize.literal('CURRENT_TIMESTAMP'),
+      },
+      updated_at: {
+        type: DataTypes.DATE,
+        allowNull: false,
+        defaultValue: Sequelize.literal('CURRENT_TIMESTAMP'),
+      },
+    })
+
+${indexes}
+  },
+
+  async down(queryInterface) {
+    await queryInterface.dropTable('${tableName(resource)}')
+  },
+}
+`
+}