Syntax error at or near ошибка

alter user dell-sys with password 'Pass@133';

ERROR:  syntax error at or near "-"
LINE 1: alter user dell-sys with password 'Pass@133';
                       ^

1

PREVENT YOUR SERVER FROM CRASHING!

Never again lose customers to poor server speed! Let us help you.

Our server experts will monitor & maintain your server 24/7 so that it remains lightning fast and secure.

GET STARTED

QueryFailedError: syntax error at or near "WHERE"
    at PostgresQueryRunner.query (C:UsersYassineDesktopnesttrainingnestjs-task-managementsrcdriverpostgresPostgresQueryRunner.ts:299:19)
    at processTicksAndRejections (node:internal/process/task_queues:96:5)
    at SelectQueryBuilder.loadRawResults (C:UsersYassineDesktopnesttrainingnestjs-task-managementsrcquery-builderSelectQueryBuilder.ts:3601:25)
    at SelectQueryBuilder.getRawMany (C:UsersYassineDesktopnesttrainingnestjs-task-managementsrcquery-builderSelectQueryBuilder.ts:1573:29)
    at SelectQueryBuilder.executeEntitiesAndRawResults (C:UsersYassineDesktopnesttrainingnestjs-task-managementsrcquery-builderSelectQueryBuilder.ts:3295:26)
    at SelectQueryBuilder.getRawAndEntities (C:UsersYassineDesktopnesttrainingnestjs-task-managementsrcquery-builderSelectQueryBuilder.ts:1617:29)
    at SelectQueryBuilder.getOne (C:UsersYassineDesktopnesttrainingnestjs-task-managementsrcquery-builderSelectQueryBuilder.ts:1644:25)
    at UsersRepository.findByUsername (C:UsersYassineDesktopnesttrainingnestjs-task-managementsrcauthusers.repository.ts:32:21)
    at AuthService.signIn (C:UsersYassineDesktopnesttrainingnestjs-task-managementsrcauthauth.service.ts:20:22)
    at C:UsersYassineDesktopnesttrainingnestjs-task-managementnode_modules@nestjscorerouterrouter-execution-context.js:46:28 {
  query: 'SELECT DISTINCT "distinctAlias"."User_id" AS "ids_User_id" FROM (SELECT "User"."id" AS "User_id", "User"."username" AS "User_username", "User"."password" AS "User_password", "User_tasks"."id" AS "User_tasks_id", "User_tasks"."title" AS "User_tasks_title", "User_tasks"."description" AS "User_tasks_description", "User_tasks"."status" AS "User_tasks_status" FROM "user" "User" LEFT JOIN "task" "User_tasks" ON  WHERE ("User"."username" = $1)) "distinctAlias" ORDER BY "User_id" ASC LIMIT 1',
  parameters: [ 'toutou' ],
  driverError: error: syntax error at or near "WHERE"
      at Parser.parseErrorMessage (C:UsersYassineDesktopnesttrainingnestjs-task-managementnode_modulespg-protocolsrcparser.ts:369:69)
      at Parser.handlePacket (C:UsersYassineDesktopnesttrainingnestjs-task-managementnode_modulespg-protocolsrcparser.ts:188:21)
      at Parser.parse (C:UsersYassineDesktopnesttrainingnestjs-task-managementnode_modulespg-protocolsrcparser.ts:103:30)
      at Socket.<anonymous> (C:UsersYassineDesktopnesttrainingnestjs-task-managementnode_modulespg-protocolsrcindex.ts:7:48)
      at Socket.emit (node:events:390:28)
      at addChunk (node:internal/streams/readable:315:12)
      at readableAddChunk (node:internal/streams/readable:289:9)
      at Socket.Readable.push (node:internal/streams/readable:228:10)
      at TCP.onStreamRead (node:internal/stream_base_commons:199:23) {
    length: 95,
    severity: 'ERROR',
    code: '42601',
    detail: undefined,
    hint: undefined,
    position: '411',
    internalPosition: undefined,
    internalQuery: undefined,
    where: undefined,
    schema: undefined,
    table: undefined,
    column: undefined,
    dataType: undefined,

import { Task } from "src/tasks/task.entity";
import { Column, Entity, OneToMany, PrimaryGeneratedColumn } from "typeorm";

@Entity()
export class User {
    @PrimaryGeneratedColumn('uuid')
    id: string;

    @Column({unique: true})
    username: string;

    @Column()
    password: string;

    @OneToMany((_type) => Task, (task) => task.user, { eager: true})
    tasks: Task[];
}

import { TaskStatus } from './task-status.enum';
import { Column, Entity, ManyToMany, PrimaryGeneratedColumn } from "typeorm";
import { User } from 'src/auth/user.entity';

@Entity()
export class Task {

    @PrimaryGeneratedColumn('uuid')
    id: string;

    @Column()
    title: string;

    @Column()
    description: string;

    @Column()
    status: TaskStatus;

    @ManyToMany((_type) => User, (user) => user.tasks, { eager: false})
    user: User
}

import { AuthCredentialsDTO } from './dto/auth-credentials.dto';
import { Repository } from 'typeorm';
import { User } from './user.entity';
import { InjectRepository } from "@nestjs/typeorm";
import { ConflictException, InternalServerErrorException, Param } from '@nestjs/common';
import * as bcrypt from 'bcrypt';

export class UsersRepository {
    constructor(@InjectRepository(User) readonly repo: Repository<User>){
        console.log("users repository");
    }

    async createUser(authCredentialsDTO: AuthCredentialsDTO): Promise<void>{
        const {username, password} = authCredentialsDTO;

        const salt = await bcrypt.genSalt();
        const hashedPassword = await bcrypt.hash(password, salt);

        const user = this.repo.create({username, password: hashedPassword});
        try{
            await this.repo.save(user);
        }catch(error){
            if(error.code === '23505'){ // duplicate username
                throw new ConflictException('Username already exists')
            } else {
                throw new InternalServerErrorException();
            }
        }
    }

    async findByUsername(username: string): Promise<any>{
        try {return await this.repo.findOne({where: {username}})
    } catch (error){
        console.log(error);
    }
    }
}

import { AuthCredentialsDTO } from './dto/auth-credentials.dto';
import { UsersRepository } from './users.repository';
import { Injectable, NotFoundException, Post, UnauthorizedException } from '@nestjs/common';
import * as bcrypt from 'bcrypt';
import { JwtService } from '@nestjs/jwt';
import { JwtPayload } from './jwt-payload.interface';

@Injectable()
export class AuthService {
    constructor( private usersRepository: UsersRepository,
        private jwtService: JwtService){}

    signUp(authCredentialsDTO: AuthCredentialsDTO): Promise<void>{
        return this.usersRepository.createUser(authCredentialsDTO);
    }

    async signIn(authCredentialsDTO: AuthCredentialsDTO): Promise<{accessToken: string}>{
        const {username, password} = authCredentialsDTO;
        console.log('my username in  auth ', username, ' my pass word in auth: ', password)
        const user = await this.usersRepository.findByUsername(username);
        console.log('my user: ', user);

        if(user && (await bcrypt.compare(password, user.password))){
            const payload: JwtPayload = { username};
            const accessToken: string = await this.jwtService.sign(payload);
            return {accessToken};
        } else {
             throw new UnauthorizedException('Please check your credentials');
        }
    }
}

import { User } from './user.entity';
import { AuthCredentialsDTO } from './dto/auth-credentials.dto';
import { AuthService } from './auth.service';
import { Body, Controller, Get, Post, Req, UseGuards } from '@nestjs/common';
import { AuthGuard } from '@nestjs/passport';

@Controller('auth')
export class AuthController {
    constructor(private authService: AuthService){}

    @Get()
    getUsers(){
        return "hello world";
    }

    @Post('/signup')
    signUp(@Body() authCredentialsDTO: AuthCredentialsDTO): Promise<void>{
        return this.authService.signUp(authCredentialsDTO);    
    }

    @Post('/signin')
    signIn(@Body() authCredentialsDTO: AuthCredentialsDTO): Promise<{accessToken: string}>{
        return this.authService.signIn(authCredentialsDTO);    
    }

    @Post('/test')
    @UseGuards(AuthGuard())
    test(@Req() req){
        console.log('>'.repeat(20), req.user);
    }
}

// insert code here

psql -U dbuser hosts -h dbhost -c 'INSERT INTO HOSTS ('type','name') VALUES ('"test"', '"10.100.133.1"')'
Password for user dbusr:
ERROR:  syntax error at or near ".133"
LINE 1: INSERT INTO HOSTS (type,name) VALUES (test, 10.100.133.1)
                                                          ^

2