Xen_mar's questions

Estou tentando espelhar um repositório público pertencente à minha organização no GitHub (sou administrador da organização) para um repositório privado na minha conta pessoal. Fiz o seguinte:

• Criei um token de acesso granular com muitas permissões (fiquei um pouco desesperado) Read and Write access to Dependabot alerts, actions, actions variables, administration, attestations api, code, codespaces, codespaces lifecycle admin, codespaces secrets, commit statuses, dependabot secrets, deployments, discussions, environments, issues, merge queues, pages, pull requests, repository advisories, repository custom properties, repository hooks, secret scanning alerts, secrets, security events, and workflows
• Verifiquei 100x se o token tem acesso ao meu repositório privado pessoal
• Fluxos de trabalho habilitados para execução no meu repositório pessoal:

Mas continuo vendo o erro:

> Run git remote add private
> https://***@github.com/xxxx.git
> origin    https://github.com/yyyy (fetch)
> origin    https://github.com/yyyy (push)
> private   https://***@github.com/xxxx.git
> (fetch)
> private   https://***@github.com/xxxx.git
> (push) remote: Permission to xxxx.git
> denied to github-actions[bot]. fatal: unable to access
> 'https://github.com/xxxx/': The
> requested URL returned error: 403 Error: Process completed with exit
> code 128.

Minha ação no github é definida da seguinte forma:

name: Mirror Repository

on:
  push:
    branches: [main]
  workflow_dispatch: # Allows manual triggering of the workflow

jobs:
  mirror:
    runs-on: ubuntu-latest
    permissions:
      contents: write
    steps:
      - name: Checkout repository
        uses: actions/checkout@v4
        with:
          fetch-depth: 0 # Fetch all history for all branches and tags

      - name: Push to private mirror
        env:
          PERSONAL_ACCESS_TOKEN: ${{ secrets.PERSONAL_ACCESS_TOKEN }}
        run: |
          git remote add private https://${{ secrets.PERSONAL_ACCESS_TOKEN }}@github.com/xxxx.git
          # Debug: List remotes to verify
          git remote -v
          git push private --force --all
          git push private --force --tags

Alguém pode me ajudar? Estou sem ideias.

Sou novo no Rust & Axum e estou tentando entender como configurar uma arquitetura escalonável e limpa. Ao executar localmente, às vezes noto um atraso antes da resposta chegar. Isso pode ter vários motivos, mas uma coisa que estou investigando é como estou compartilhando meu pool de conexões.

Este é o principal.rs

#[tokio::main]
async fn main() -> Result<(), Box<dyn error::Error>> {
    let db_url = std::env::var("DATABASE_URL").expect("DATABASE_URL must be set");
    let pool = PgPool::connect(&db_url).await.expect("Failed to connect to database");

    let repository_organization = PostgresRepositoryOrganization::new(pool.clone());

    let service_organization = OrganizationService::new(Arc::new(repository_organization));

    let app = Router::new()
        .nest(
            "/organizations",
            Router::new()
                .route("/", post(controller_organization::create_organization))
                .layer(from_fn(authenticated_user::auth_middleware)),
        )
        .layer(Extension(service_organization))

    let addr = SocketAddr::from(([0, 0, 0, 0], 3000));

    let listener = tokio::net::TcpListener::bind(&addr).await.unwrap();
    axum::serve(listener, app).await.unwrap();

    Ok(())
}

No meu aplicativo de produção, eu teria muitos controladores e serviços. Muitas vezes vejo propriedade compartilhada tratada com um Arcponteiro Mutexinteligente, mas não tenho certeza se isso é apropriado.

Há alguém aqui capaz de me dizer se essa abordagem está correta ou apresenta efeitos colaterais desconhecidos para mim?

Sou um iniciante em ferrugem e ainda estou muito confuso. No meu módulo atual, estou tentando usar o validtorcreate conforme sugerido pelos documentos .

use once_cell::sync::Lazy;
use regex::Regex;
use serde::{Deserialize, Serialize};
use sqlx::types::Uuid;
use validator::Validate;

static RE_PASSWORDS: Lazy<Regex> =
    Lazy::new(|| Regex::new(r"^(?=.*[A-Za-z])(?=.*\d)[A-Za-z\d]{8,}$").unwrap());

#[derive(Debug, Deserialize, Validate)]
pub struct CreateUserDto {
    #[validate(length(min = 1, max = 100))]
    pub name: String,
    #[validate(email)]
    pub email: String,
    #[validate(regex = "RE_PASSWORDS")] // <- Unexpected type `string`
    pub password: String,
}

Estou vendo o seguinte erro que marquei no recorte: Unexpected type 'string'.

Tentei a sintaxe alternativa (não tenho certeza qual é a diferença entre as duas, embora o erro sugira que tem a ver com desreferenciação):

#[validate(regex(path = "RE_PASSWORDS"))]

Isso produz um novo erro:

o limite da característica once_cell::sync::Lazy<regex::Regex>: validator::validation::regex::AsRegexnão é satisfeito, necessário para &once_cell::sync::Lazy<regex::Regex>implementarvalidator::validation::regex::AsRegex

[dependencies]
[...]
once_cell = "1.19.0"
dotenv = "0.15.0"
regex = "1.10.6"
validator_derive = "0.18.1"
lazy_static = "1.5.0"

Alguém pode ajudar?

Eu continuo tropeçando no uso de 'in' ao restringir os tipos de união. E fico me perguntando por que não podemos simplesmente verificar o imóvel para que o estreitamento funcione?

Exemplo...

type Obj1 = {
  message: string
}

type Obj2 = {
  text: string
}

const getText = (obj: Obj1 | Obj2): string => {
  if (obj.message) { // <- 'message' does not exist on type 'Obj1 | Obj2'
    return obj.message
  }

  return obj.text
}

Em vez disso, temos que escrever:

const getText2 = (obj: Obj1 | Obj2): string => {
  if ("message" in obj) {
    return obj.message
  }

  return obj.text
}

Por que?