javascript

require('dotenv').config({ path: __dirname + '/../../.env' });
const { body, validationResult } = require('express-validator');
const supabaseUrl = process.env.SUPABASE_URL;
const supabaseKey = process.env.SUPABASE_ANON_KEY;
const { createClient } = require('@supabase/supabase-js');
const supabase = createClient(supabaseUrl, supabaseKey);
// const csrf = require('csrf');
const { v4: uuidv4 } = require('uuid');

// POST /articles
exports.createArticle = [
    // Use express-validator middleware for input validation
    body('author_id').isInt(),
    body('article_title').notEmpty(),
    body('summary').notEmpty(),
    body('content').notEmpty(),
  
    async (req, res, next) => {
      const client = await supabase.pool.connect(); // acquire a connection from the pool
      try {
        await client.query('BEGIN ISOLATION LEVEL SERIALIZABLE'); // begin a transaction with serializable isolation level
  
        const errors = validationResult(req);
        if (!errors.isEmpty()) {
          return res.status(400).json({ errors: errors.array() });
        }
  
        const { data: maxArticleId, error: maxArticleIdError } = await supabase
          .from('articles')
          .select('MAX(article_id) as max_article_id');
        if (maxArticleIdError) {
          await client.query('ROLLBACK'); // rollback the transaction if an error occurred
          return next(maxArticleIdError);
        }
  
        const nextArticleId = maxArticleId[0].max_article_id + 1;
  
        const { data: article, error } = await supabase
          .from('articles')
          .insert({
            article_id: nextArticleId,
            author_id: req.body.author_id,
            article_title: req.body.article_title,
            summary: req.body.summary,
            content: req.body.content,
          });
  
        if (error) {
          await client.query('ROLLBACK'); // rollback the transaction if an error occurred
          return next(error);
        }
  
        await client.query('COMMIT'); // commit the transaction if there were no errors
  
        res.json({ message: 'Article created successfully!' });
      } catch (error) {
        await client.query('ROLLBACK'); // rollback the transaction if an error occurred
        next(error);
      } finally {
        client.release(); // release the connection back to the pool
      }
    },
  ];

remaining connection slots are reserved for non-replication superuser connections

supabase db remote commit

alter table "storage"."buckets" add column "allowed_mime_types" text[];

alter table "storage"."buckets" add column "avif_autodetection" boolean default false;

alter table "storage"."buckets" add column "file_size_limit" bigint;

alter table "storage"."objects" add column "version" text;

supabase start

Error: Migration failed. Reason: An error occurred running 'add-automatic-avif-detection-flag'. Rolled back this migration. No further migrations were run. Reason: column "avif_autodetection" of relation "buckets" already exists

app

event.locals.supabase = createSupabaseServerClient({
        supabaseUrl: PUBLIC_SUPABASE_URL,
        supabaseKey: PUBLIC_SUPABASE_ANON_KEY,
        event
    });

POST: RequestHandler = async ({ request, locals: { supabase, getSession } })

+server.ts

const session = await getSession();
        if (!session) {
            // the user is not signed in
            throw new Error('Unauthorized');
        }

const { error } = await supabase
            .from('messages')
            .insert({ message: message) });

error: {
    code: '42501',
    details: null,
    hint: null,
    message: 'permission denied for schema public'
  }

supabaseKey: PUBLIC_SUPABASE_SECRET_KEY

hooks.server.ts

ts
import { createMiddlewareSupabaseClient } from '@supabase/auth-helpers-nextjs';
import { NextResponse } from 'next/server';

import type { NextRequest } from 'next/server';

export async function middleware (req: NextRequest) {
  const res = NextResponse.next();
  const supabase = createMiddlewareSupabaseClient({ req, res });
  await supabase.auth.getSession();
  return res;
}

createMiddlewareSupabaseClient

const { data, error } = await supabase.rpc('hello_world')

Argument of type 'string' is not assignable to parameter of type 'never'.ts(2345)

// supabaseCustom.d.ts

import { PostgrestBuilder } from '@supabase/postgrest-js';
import { SupabaseClient } from '@supabase/supabase-js';

declare module '@supabase/supabase-js' {
  interface SupabaseClient {
    rpc<ResponseType, ParamsType>(
      fn: string,
      params?: ParamsType
    ): PostgrestBuilder<ResponseType>;
  }
}

let session = try await supabase.auth.session(from: url)

SELECT * FROM cron.job

/functions/_core/dbtypes.ts

/functions/_api/supabase.ts

{
  "imports": {
    "/": "./",
    "./": "./"
  }
}

unexpected response while creating upload, originated from request (method: POST, url: https://wmsccjgcrykictvgimtt.supabase.co/storage/v1/upload/resumable, response code: 404, response text: {"message":"Route POST:/upload/resumable not found","error":"Not Found","statusCode":404}, request id: n/

supaClient
      .from('messages')
      .stream(primaryKey: ['id'])
      .order('createdAt')

getUser()

/auth/v1/user

/user