Swift: Шаблонный бэкенд с использованием Vapor15.04.2025 10:01

# ================================
# Build image
# ================================
FROM swift:5.7-jammy as build

# Install OS updates and, if needed, sqlite3
RUN export DEBIAN_FRONTEND=noninteractive DEBCONF_NONINTERACTIVE_SEEN=true \
    && apt-get -q update \
    && apt-get -q dist-upgrade -y\
    && rm -rf /var/lib/apt/lists/*

# Set up a build area
WORKDIR /build

# First just resolve dependencies.
# This creates a cached layer that can be reused
# as long as your Package.swift/Package.resolved
# files do not change.
COPY ./Package.* ./
RUN swift package resolve

# Copy entire repo into container
COPY . .

# Build everything, with optimizations
RUN swift build -c release --static-swift-stdlib

# Switch to the staging area
WORKDIR /staging

# Copy main executable to staging area
RUN cp "$(swift build --package-path /build -c release --show-bin-path)/Run" ./

# Copy resources bundled by SPM to staging area
RUN find -L "$(swift build --package-path /build -c release --show-bin-path)/" -regex '.*\.resources$' -exec cp -Ra {} ./ \;

# Copy any resources from the public directory and views directory if the directories exist
# Ensure that by default, neither the directory nor any of its contents are writable.
RUN [ -d /build/Public ] && { mv /build/Public ./Public && chmod -R a-w ./Public; } || true
RUN [ -d /build/Resources ] && { mv /build/Resources ./Resources && chmod -R a-w ./Resources; } || true

# ================================
# Run image
# ================================
FROM ubuntu:jammy

# Make sure all system packages are up to date, and install only essential packages.
RUN export DEBIAN_FRONTEND=noninteractive DEBCONF_NONINTERACTIVE_SEEN=true \
    && apt-get -q update \
    && apt-get -q dist-upgrade -y \
    && apt-get -q install -y \
      ca-certificates \
      tzdata \
# If your app or its dependencies import FoundationNetworking, also install `libcurl4`.
      # libcurl4 \
# If your app or its dependencies import FoundationXML, also install `libxml2`.
      # libxml2 \
    && rm -r /var/lib/apt/lists/*

# Create a vapor user and group with /app as its home directory
RUN useradd --user-group --create-home --system --skel /dev/null --home-dir /app vapor

# Switch to the new home directory
WORKDIR /app

# Create Storage
RUN mkdir -p /app/storage/avatars
RUN mkdir -p /app/storage/images
RUN chmod a+w /app/storage/avatars
RUN chmod a+w /app/storage/images

# Copy APNS to container
COPY ./AuthKey.p8 /app

# Copy built executable and any staged resources from builder
COPY --from=build --chown=vapor:vapor /staging /app

# Ensure all further commands run as the vapor user
USER vapor:vapor

# Let Docker bind to port 8080
EXPOSE 8080

# Start the Vapor service when the image is run, default to listening on 8080 in production environment
ENTRYPOINT ["./Run"]
CMD ["serve", "--env", "production", "--hostname", "0.0.0.0", "--port", "8080"]

version: '3.7'

x-shared_environment: &shared_environment
  LOG_LEVEL: ${LOG_LEVEL:-debug}
  DATABASE_HOST: db
  DATABASE_NAME: ${POSTGRES_DB:-hermes_database}
  DATABASE_USERNAME: ${POSTGRES_USER:-hermes_username}
  DATABASE_PASSWORD: ${POSTGRES_PASSWORD:-hermes_password}
  STORAGE_AVATARS: storage/avatars
  STORAGE_IMAGES: storage/images
  SMTP_HOST: smtp.gmail.com
  SMTP_PORT: 465
  SMTP_AUTH: 
  SMTP_PASS: 

  
services:
  db:
    image: postgres:14-alpine
    volumes:
      - db_data:/var/lib/postgresql/data/
    environment:
      POSTGRES_USER: ${POSTGRES_USER:-hermes_username}
      POSTGRES_PASSWORD: ${POSTGRES_PASSWORD:-hermes_password}
      POSTGRES_DB: ${POSTGRES_DB:-hermes_database}
    ports:
      - "5432:5432"
    networks:
        - hermes
  app:
    image: hermes:latest
    build:
      context: .
    environment:
      <<: *shared_environment
    depends_on:
      - db
    ports:
      - "8080:8080"
    # user: '0' # uncomment to run as root for testing purposes even though Dockerfile defines 'vapor' user.
    command: ["serve", "--env", "production", "--hostname", "0.0.0.0", "--port", "8080"]
    volumes:
      - ../storage/avatars:/app/storage/avatars
      - ../storage/images:/app/storage/images
    networks:
        - hermes
  migrate:
    image: hermes:latest
    build:
      context: .
    environment:
      <<: *shared_environment
    depends_on:
      - db
    command: ["migrate", "--yes"]
    deploy:
      replicas: 0
  revert:
    image: hermes:latest
    build:
      context: .
    environment:
      <<: *shared_environment
    depends_on:
      - db
    command: ["migrate", "--revert", "--yes"]
    deploy:
      replicas: 0

#  mosquitto:
#    image: eclipse-mosquitto:latest
#    ports:
#        - 1883:1883
#        - 8883:8883
#        - 9001:9001
#    volumes:
#        - ../storage/mosquitto/data:/mosquitto/data
#        - ../storage/mosquitto/log:/mosquitto/log
#    networks:
#        - hermes

  mqtt:
    image: demonsoft/hermes_mqtt:v1
    ports:
        - 1883:1883
        - 8883:8883
        - 9001:9001
    volumes:
        - ../storage/mosquitto/data:/mosquitto/data
        - ../storage/mosquitto/log:/mosquitto/log
    networks:
        - hermes

networks:
    hermes:
        name: hermes
        driver: bridge


volumes:
  storage:
  db_data:

import Fluent
import FluentPostgresDriver
import Vapor
import Smtp
import APNS
import JWTKit

// configures your application
public func configure(_ app: Application) throws {
    // uncomment to serve files from /Public folder
    // app.middleware.use(FileMiddleware(publicDirectory: app.directory.publicDirectory))

    app.databases.use(.postgres(
        hostname: Environment.get("DATABASE_HOST")      ?? "localhost",
        port: Environment.get("DATABASE_PORT").flatMap(Int.init(_:)) ?? PostgresConfiguration.ianaPortNumber,
        username: Environment.get("DATABASE_USERNAME")  ?? "hermes_username",
        password: Environment.get("DATABASE_PASSWORD")  ?? "hermes_password",
        database: Environment.get("DATABASE_NAME")      ?? "hermes_database"
    ), as: .psql)

    app.migrations.add(Profile.Migration())
    app.migrations.add(User.Migration())
    app.migrations.add(Product.Migration())
    app.migrations.add(UserToken.Migration())
    app.migrations.add(Confirmation.Migration())
    app.migrations.add(Image.Migration())
    app.migrations.add(PushToken.Migration())
    app.migrations.add(Push.Migration())
    try app.autoMigrate().wait()
    
    // SMTP
    let smtp_host = Environment.get("SMTP_HOST")        ?? "smtp.gmail.com"
    let smtp_port = Int(Environment.get("SMTP_PORT")    ?? "") ?? 465
    let smtp_auth = Environment.get("SMTP_AUTH")        ?? ""
    let smtp_pass = Environment.get("SMTP_PASS")        ?? ""
    app.smtp.configuration.hostname     = smtp_host
    app.smtp.configuration.port         = smtp_port
    app.smtp.configuration.secure       = .ssl
    app.smtp.configuration.signInMethod = .credentials(username: smtp_auth, password: smtp_pass)
                                                        
    
    // ONLY FOR PRODUCT - It restricts using API
    // app.middleware.use(CerberusMiddleware())

    // register routes
    try routes(app)
    
    
    
    // THIS IS TEMPORARY CODE ---------------------------
    //    let fileMngr = FileManager.default
    //    let current = "\(fileMngr.currentDirectoryPath)"
    //    print("[ PATH: ] \(current)")
    //    let files = try fileMngr.contentsOfDirectory(atPath:current)
    //    print("[ FILES: ] \(files)")
    // THIS IS TEMPORARY CODE ---------------------------

    // Configure APNS using JWT authentication.
    app.apns.configuration = try .init(
        authenticationMethod: .jwt(
            key: .private(filePath: Constants.apnCertPath),
            keyIdentifier: JWKIdentifier(string: Constants.keyIdentifier),
            teamIdentifier: Constants.teamIdentifier
        ),
        topic: Constants.apnTopic,
        environment: .sandbox
    )
    
    //app.lifecycle.use(Storage())
}

//
//  File.swift
//  
//
//  Created by Dmitriy Soloshenko on 13.03.2023.
//

import Foundation
import RoutingKit

struct Constants {
    static let lifetime        = 30 // Lifetime of auth token. 30 days
    static let lifetimePass    = Date.oneHour // Lifetime of change password. 1 hour
    static let restoreAcc      = 30 // Duration that user can restore account after delete. 30 days
    static let xTokenHeader    = "X-Token"
    static let xTokenValue     = ""
    static let bcryptSalt      = ""
    static let xBearer         = "Bearer"
    static let avatarStorage   = "storage/avatars/"
    static let imageStorage    = "storage/images/"
    static let avatarExtension = ".jpg"
    static let imageExtension  = ".jpg"
    static let minimalPassword = 8
    static let iosAppName      = "hermesApp"

    // MARK: - NETWORK
    static let restRootGroup   = PathComponent("api")
    static let restVersion     = PathComponent("v.1")
    
    static let backEmail       = ""
    static let serviceName     = "Hermes Core Server"
    
    
    // MARK: - APN
    static let apnCertPath       = "AuthKey.p8"
    static let keyIdentifier     = ""
    static let teamIdentifier    = ""
    static let apnTopic          = "com.."

    
    // MARK: - Deep links
    static let restoreAccDL       = "://restore-acc/"
    static let resetPassDL        = "://reset-password/"
    static let confirmChangeDL    = "://confirm-change/"
    
    
    // MARK: - STRIPE
    static let stipePublicKey =
    "pk_test_"
    static let stipePrivateKey =
    "sk_test_"
    
}

import Fluent
import Vapor

final class User: Model, Content {
    static var schema: String = "users"

    @ID                         var id: UUID?
    @Field(key: "email")        var email: String
    @Field(key: "password")     var password: String
    @Field(key: "social_id")    var socialId: String?
    @Parent(key: "profile_id")  var profile: Profile
    @Timestamp(key: "created_at", on: .create)  var createdAt: Date?
    @Timestamp(key: "updated_at", on: .update)  var updatedAt: Date?
    @Timestamp(key: "deleted_at", on: .delete)  var deletedAt: Date?
    
    init() {}
    
    init(id: UUID? = nil,
         email: String,
         password: String,
         socialId: String? = nil,
         profile: Profile.IDValue) {
        self.id           = id
        self.email        = email
        self.password     = password
        self.socialId     = socialId
        self.$profile.id  = profile
    }
}

import Fluent
import Vapor

final class Profile: Model, Content {
    enum Gender: String, Codable {
        case unknown, male, female
    }

    static var schema: String = "profiles"

    @ID(key: .id)              var id: UUID?
    @Field(key: "first_name")  var first_name: String
    @Field(key: "last_name")   var last_name: String
    @Field(key: "nickname")    var nickname: String
    @Enum(key: "gender")       var gender: Gender
    @Field(key: "age")         var age: Int?
    @Enum(key: "role")         var role: Role
    @Field(key: "avatar")      var avatar: UUID?
    @Timestamp(key: "created_at", on: .create)  var createdAt: Date?
    @Timestamp(key: "updated_at", on: .update)  var updatedAt: Date?
    @Timestamp(key: "deleted_at", on: .delete)  var deletedAt: Date?

    init() {}
    
    init(id: UUID = UUID(),
         first_name: String = "",
         last_name: String = "",
         nickname: String = "",
         gender: Gender = .unknown,
         age: Int? = nil,
         role: Role = .user,
         avatar: UUID? = nil) {
        self.id          = id
        self.first_name  = first_name
        self.last_name   = last_name
        self.nickname    = nickname
        self.gender      = gender
        self.age         = age
        self.role        = role
        self.avatar      = avatar
    }
    
    struct Public: Content, Encodable, Hashable {
        let id: UUID?
        let first_name: String
        let last_name: String
        let nickname: String
        let gender: Gender
        let age: Int?
        let role: Role?
        let avatar: UUID?
    }
}

import Fluent

extension Profile {
    struct Migration: AsyncMigration {
        func prepare(on database: Database) async throws {
            try await database.schema("profiles")
                .id()
                .field("first_name",    .string, .required)
                .field("last_name",     .string, .required)
                .field("nickname",      .string, .required)
                .field("gender",        .string, .required)
                .field("age",           .int)
                .field("role",          .string, .required)
                .field("avatar",        .uuid)
                .field("created_at",    .datetime)
                .field("updated_at",    .datetime)
                .field("deleted_at",    .datetime)
                .create()
        }
        
        func revert(on database: Database) async throws {
            try await database.schema("profiles").delete()
        }
    }
}

import Fluent

extension User {
    struct Migration: AsyncMigration {
        func prepare(on database: Database) async throws {
            try await database.schema("users")
                .id()
                .field("email",       .string, .required)
                .field("password",    .string, .required)
                .field("social_id",   .string)
                .field("profile_id",  .uuid,   .required, .references("profiles", "id"))
                .field("created_at",  .datetime)
                .field("updated_at",  .datetime)
                .field("deleted_at",  .datetime)
                .unique(on: "email")
                .create()
        }
        
        func revert(on database: Database) async throws {
            try await database.schema("users").delete()
        }
    }
}

import Fluent
import Vapor

struct ProductController: RouteCollection {
    func boot(routes: RoutesBuilder) throws {
        let products = routes.root.grouped("products")

        let protected = products.grouped(UserToken.authenticator())
        protected.get(use: index)
        protected.post(use: create)
        protected.put(":id", use: update)
        protected.delete(":id", use: delete)
    }
    
    func index(req: Request) async throws -> Response {
        try await Profile.auth(req)
        let products =  try await Product.query(on: req.db).all()
        return Response.success(products)
    }
    
    func create(req: Request) async throws -> Response {
        try await Profile.auth(req)
        guard let product = try? req.content.decode(Product.self) else {
            return Response.fail(Mistakes.iAmTeapot)
        }
        try await product.save(on: req.db)
        return Response.success(product)
    }

    func update(req: Request) async throws -> Response {
        try await Profile.auth(req)
        guard let product = try await Product.find(req.parameters.get("id"), on: req.db) else {
            return Response.fail(Mistakes.idNotFound)
        }
        
        let updated      = try req.content.decode(Product.self)
        product.name     = updated.name
        product.weight   = updated.weight
        product.price    = updated.price
        product.currency = product.currency
        try await product.save(on: req.db)
        
        return Response.success(product)
    }
    
    func delete(req: Request) async throws -> Response {
        try await Profile.auth(req)
        guard let product = try await Product.find(req.parameters.get("id"), on: req.db) else {
            return Response.fail(Mistakes.productCannotDelete)
        }
        try await product.delete(on: req.db)
        return Response.success("OK")
    }
}

import Vapor
import Fluent

final class CerberusMiddleware: AsyncMiddleware {
    func respond(to request: Request, chainingTo next: AsyncResponder) async throws -> Response {
        guard request.headers.contains(name: Constants.xTokenHeader),
              let value = request.headers[Constants.xTokenHeader].first,
              value == Constants.xTokenValue
        else { throw self.exception(request) }
        
        return try await next.respond(to: request)
    }
    
    private func exception(_ request: Request) -> Abort {
        let errorResponse = Response(status: .forbidden)
        let message = "This API isn't accessible for public using."
        errorResponse.body = .init(string: message)
        return Abort(.badRequest, reason: message)
    }
}

import Vapor
import Fluent

final class RolesMiddleware: AsyncMiddleware {
    func respond(to request: Request, chainingTo next: AsyncResponder) async throws -> Response {
        let profile = try await request.me()
        guard profile.role.available(.manager) else {
            throw Abort (.forbidden)
        }
        
        return try await next.respond(to: request)
    }
}

import Foundation
import Vapor

class Storage: LifecycleHandler {
    // Called before application boots.
    func willBoot(_ app: Application) throws {
        
        do {
            try createIfNotExist(app, Environment.get("STORAGE_AVATARS") ?? Constants.avatarStorage)
            try createIfNotExist(app, Environment.get("STORAGE_IMAGES") ?? Constants.imageStorage)
        }
        catch let e {
            print("FILE SYSTEM: \(e.localizedDescription)")
        }
    }
    
    private func createIfNotExist(_ app: Application, _ path: String) throws {
        let fullPath = app.directory.workingDirectory + path
        try FileManager.default.createDirectory(atPath: fullPath, withIntermediateDirectories: true)
    }
}

import Fluent
import Vapor
import APNS

class PushSender {
    func send(req: Request, tokens:[PushToken], title: String, subtitle: String?, body: String?) async throws {
        for token in tokens {
            let unread = try await token.countUnread(req)
            let alert  = APNSwiftAlert(title: title, subtitle: subtitle, body: body)
            let aps    = APNSwiftPayload(alert: alert, badge: unread + 1, sound: .normal("cow.wav"))
            let _      = req.apns.send(aps, to: token.token)
            
            guard let id = token.id else { throw Abort(.internalServerError) }
            let push = Push(pushToken: id, title: title, subtitle: subtitle, body: body)
            try await push.save(on: req.db)
        }
    }
}