Caching system failure.

import { authQuery } from "../../procedures";
import { internal } from "../../_generated/api";
import { v } from "convex/values";
import { internalQuery } from "../../_generated/server";

type Result = null | {
  url: string,
  width: number,
  height: number,
  size: number,
  isAlpha: boolean,
}

export const _internal = internalQuery({
  args: { projectId: v.id('projects') },
  handler: async (ctx, args): Promise<Result> => {
    const project = await ctx.db.get(args.projectId);
    if (!project) { throw new Error("Project not found"); }

    const resultId = project.resultIds[project.resultIds.length - 1] ?? null;
    const result = !resultId ? null :
      await ctx.runQuery(internal.router.storage.getImage._internal, { id: resultId })

    if (!result) { return null; }

    return {
      url: result.sizes.thumbnail.url,
      width: result.width,
      height: result.height,
      size: result.size,
      isAlpha: result.hasAlpha,
    };
  }
})

export const client = authQuery({
  args: { projectId: v.id('projects') },
  handler: async (ctx, args): Promise<Result> =>
    ctx.runQuery(internal.router.projects.getCover._internal, args)
})

import { authQuery } from "../../procedures";
import { internal } from "../../_generated/api";
import { v } from "convex/values";
import { internalQuery } from "../../_generated/server";

type Result = null | {
  url: string,
  width: number,
  height: number,
  size: number,
  isAlpha: boolean,
}

export const _internal = internalQuery({
  args: { projectId: v.id('projects') },
  handler: async (ctx, args): Promise<Result> => {
    const project = await ctx.db.get(args.projectId);
    if (!project) { throw new Error("Project not found"); }

    const resultId = project.resultIds[project.resultIds.length - 1] ?? null;
    const result = !resultId ? null :
      await ctx.runQuery(internal.router.storage.getImage._internal, { id: resultId })

    if (!result) { return null; }

    return {
      url: result.sizes.thumbnail.url,
      width: result.width,
      height: result.height,
      size: result.size,
      isAlpha: result.hasAlpha,
    };
  }
})

export const client = authQuery({
  args: { projectId: v.id('projects') },
  handler: async (ctx, args): Promise<Result> =>
    ctx.runQuery(internal.router.projects.getCover._internal, args)
})

import { v } from "convex/values";
import { internalQuery } from "../../_generated/server";
import { Doc } from "../../_generated/dataModel";
import { internal } from "../../_generated/api";
import { SanitizedImage, sanitizeImage } from "../../lib/image/sanitizeImage";
import { publicQuery, serverQuery } from "../../procedures";

const args = {
  id: v.id('images'),
}

type BasicImage = Omit<Doc<'images'>, 'sizes'> &
{ sizes: Doc<'imageSizes'>[], objects: Doc<'imageObjects'>[] }

type Image = SanitizedImage<BasicImage>

export type GetImageReturnType = Image | null;

export const _internal = internalQuery({
  args, handler: async (ctx, { id }): Promise<Image | null> => {
    const [image, sizes, objects] = await Promise.all([
      ctx.db.get(id),
      ctx.db.query("imageSizes").withIndex("by_image_id", q => q.eq("imageId", id)).collect(),
      ctx.db.query("imageObjects").withIndex("by_image_id", q => q.eq("imageId", id)).collect(),
    ]);

    if (!image) return null;

    return sanitizeImage({
      ...image,
      sizes,
      objects,
    });
  }
})

export const client = publicQuery({
  args, handler: (ctx, args): Promise<Image | null> =>
    ctx.runQuery(internal.router.storage.getImage._internal, args)
})

export const server = serverQuery({
  args, handler: (ctx, args): Promise<Image | null> =>
    ctx.runQuery(internal.router.storage.getImage._internal, args)
})

import { v } from "convex/values";
import { internalQuery } from "../../_generated/server";
import { Doc } from "../../_generated/dataModel";
import { internal } from "../../_generated/api";
import { SanitizedImage, sanitizeImage } from "../../lib/image/sanitizeImage";
import { publicQuery, serverQuery } from "../../procedures";

const args = {
  id: v.id('images'),
}

type BasicImage = Omit<Doc<'images'>, 'sizes'> &
{ sizes: Doc<'imageSizes'>[], objects: Doc<'imageObjects'>[] }

type Image = SanitizedImage<BasicImage>

export type GetImageReturnType = Image | null;

export const _internal = internalQuery({
  args, handler: async (ctx, { id }): Promise<Image | null> => {
    const [image, sizes, objects] = await Promise.all([
      ctx.db.get(id),
      ctx.db.query("imageSizes").withIndex("by_image_id", q => q.eq("imageId", id)).collect(),
      ctx.db.query("imageObjects").withIndex("by_image_id", q => q.eq("imageId", id)).collect(),
    ]);

    if (!image) return null;

    return sanitizeImage({
      ...image,
      sizes,
      objects,
    });
  }
})

export const client = publicQuery({
  args, handler: (ctx, args): Promise<Image | null> =>
    ctx.runQuery(internal.router.storage.getImage._internal, args)
})

export const server = serverQuery({
  args, handler: (ctx, args): Promise<Image | null> =>
    ctx.runQuery(internal.router.storage.getImage._internal, args)
})

type Context = Parameters<Parameters<typeof customCtx>[0]>[0] & {
  db: DatabaseReader,
  auth: Auth;
};
export const userCheck = async (ctx: Context) => {
  // Look up the logged in user
  const userId = await getAuthUserId(ctx);
  if (!userId) throw new Error("Authentication required");
  const user = await ctx.db.get(userId);
  const userExtended = await ctx.db.query("usersExtended")
    .withIndex('by_user_id', (q) => q.eq("userId", userId)).first();

  if (!user || !userExtended) throw new Error("User not found");
  // Pass in a user to use in evaluating rules,
  // which validate data access at access / write time.
  // const db = wrapDatabaseReader({ user, userExtended }, ctx.db, {});

  const finalUser = {
    ...userExtended,
    _idExtended: userExtended._id,
    ...user,
  }

  // This new ctx will be applied to the function's.
  // The user is a new field, the db replaces ctx.db
  return { user: finalUser, userId };
}

// The base function we're extending
// Here we're using a `customCtx` helper because our modification
// only modifies the `ctx` argument to the function.
export const authQuery = customQuery(query, customCtx(userCheck));

type Context = Parameters<Parameters<typeof customCtx>[0]>[0] & {
  db: DatabaseReader,
  auth: Auth;
};
export const userCheck = async (ctx: Context) => {
  // Look up the logged in user
  const userId = await getAuthUserId(ctx);
  if (!userId) throw new Error("Authentication required");
  const user = await ctx.db.get(userId);
  const userExtended = await ctx.db.query("usersExtended")
    .withIndex('by_user_id', (q) => q.eq("userId", userId)).first();

  if (!user || !userExtended) throw new Error("User not found");
  // Pass in a user to use in evaluating rules,
  // which validate data access at access / write time.
  // const db = wrapDatabaseReader({ user, userExtended }, ctx.db, {});

  const finalUser = {
    ...userExtended,
    _idExtended: userExtended._id,
    ...user,
  }

  // This new ctx will be applied to the function's.
  // The user is a new field, the db replaces ctx.db
  return { user: finalUser, userId };
}

// The base function we're extending
// Here we're using a `customCtx` helper because our modification
// only modifies the `ctx` argument to the function.
export const authQuery = customQuery(query, customCtx(userCheck));

type PartialImage = {
  url: string,
  width: number,
  height: number,
  size: number,
}

type MainImage = PartialImage & { sizes: PartialImage[] }
type Image<T extends MainImage> = T;

export const sanitizeImage = <T extends MainImage>(image: Image<T>): SanitizedImage<T> => {
  const sizes = image.sizes.sort((a, b) => a.size - b.size).map((s) => ({ ...s, dimension: Math.max(s.width, s.height) }));
  const sanitizeSize = ({ url, width, height, size }: { url: string, width: number, height: number, size: number }) => ({ url, width, height, size });
  return {
    ...image,
    _sizes: image.sizes as typeof image['sizes'],
    sizes: {
      thumbnail: sanitizeSize(sizes.find((s) => s.dimension <= 200) ?? image),
      small: sanitizeSize(sizes.find((s) => s.dimension <= 600 && s.dimension > 200) ?? image),
      original: sanitizeSize(image),
    }
  }
}

export type SanitizedImage<T extends MainImage> =
  Omit<T, 'sizes'> & {
    _sizes: T['sizes'];
    sizes: {
      thumbnail: PartialImage;
      small: PartialImage;
      original: PartialImage;
    };
  };

type PartialImage = {
  url: string,
  width: number,
  height: number,
  size: number,
}

type MainImage = PartialImage & { sizes: PartialImage[] }
type Image<T extends MainImage> = T;

export const sanitizeImage = <T extends MainImage>(image: Image<T>): SanitizedImage<T> => {
  const sizes = image.sizes.sort((a, b) => a.size - b.size).map((s) => ({ ...s, dimension: Math.max(s.width, s.height) }));
  const sanitizeSize = ({ url, width, height, size }: { url: string, width: number, height: number, size: number }) => ({ url, width, height, size });
  return {
    ...image,
    _sizes: image.sizes as typeof image['sizes'],
    sizes: {
      thumbnail: sanitizeSize(sizes.find((s) => s.dimension <= 200) ?? image),
      small: sanitizeSize(sizes.find((s) => s.dimension <= 600 && s.dimension > 200) ?? image),
      original: sanitizeSize(image),
    }
  }
}

export type SanitizedImage<T extends MainImage> =
  Omit<T, 'sizes'> & {
    _sizes: T['sizes'];
    sizes: {
      thumbnail: PartialImage;
      small: PartialImage;
      original: PartialImage;
    };
  };

export const updateSubjectData = mutation({
  args: {
    _id: v.id("saved_atar_data"),
    subjectIndex: v.number(),
    field: v.string(),
    value: v.union(v.string(), v.number()),
    subjects: v.array(
      v.object({
        currentRawPercentage: v.float64(),
        currentScaledScore: v.float64(),
        goal1: v.float64(),
        goal2: v.float64(),
        goal3: v.float64(),
        goal4: v.float64(),
        goalRawPercentage: v.optional(v.float64()),
        goalScaledScore: v.float64(),
        maxRawPercentage: v.optional(v.float64()),
        maxScaledScore: v.float64(),
        name: v.string(),
        scaledScore: v.union(v.null(), v.float64()),
        score: v.optional(v.float64()),
        score1: v.float64(),
        score2: v.float64(),
        score3: v.float64(),
        score4: v.float64(),
        totalScore: v.float64(),
      })
    ),
    currentAtar: v.string(),
    goalAtar: v.string(),
    maxAtar: v.string(),
  },
  handler: async (ctx, args) => {
    const { _id, subjects, currentAtar, goalAtar, maxAtar } = args;

    // Verify user is authorized
    const user = await ctx.auth.getUserIdentity();
    if (!user) {
      throw new Error("Unauthorized");
    }

    // Get the existing saved data
    const savedData = await ctx.db.get(_id);
    if (!savedData) {
      throw new Error("Saved data not found");
    }

    // Update the data
    return await ctx.db.patch(_id, {
      subjects,
      current_atar: currentAtar,
      goal_atar: goalAtar,
      max_atar: maxAtar,
      // updated_at: new Date().toISOString(),
    });
  },
});

export const updateSubjectData = mutation({
  args: {
    _id: v.id("saved_atar_data"),
    subjectIndex: v.number(),
    field: v.string(),
    value: v.union(v.string(), v.number()),
    subjects: v.array(
      v.object({
        currentRawPercentage: v.float64(),
        currentScaledScore: v.float64(),
        goal1: v.float64(),
        goal2: v.float64(),
        goal3: v.float64(),
        goal4: v.float64(),
        goalRawPercentage: v.optional(v.float64()),
        goalScaledScore: v.float64(),
        maxRawPercentage: v.optional(v.float64()),
        maxScaledScore: v.float64(),
        name: v.string(),
        scaledScore: v.union(v.null(), v.float64()),
        score: v.optional(v.float64()),
        score1: v.float64(),
        score2: v.float64(),
        score3: v.float64(),
        score4: v.float64(),
        totalScore: v.float64(),
      })
    ),
    currentAtar: v.string(),
    goalAtar: v.string(),
    maxAtar: v.string(),
  },
  handler: async (ctx, args) => {
    const { _id, subjects, currentAtar, goalAtar, maxAtar } = args;

    // Verify user is authorized
    const user = await ctx.auth.getUserIdentity();
    if (!user) {
      throw new Error("Unauthorized");
    }

    // Get the existing saved data
    const savedData = await ctx.db.get(_id);
    if (!savedData) {
      throw new Error("Saved data not found");
    }

    // Update the data
    return await ctx.db.patch(_id, {
      subjects,
      current_atar: currentAtar,
      goal_atar: goalAtar,
      max_atar: maxAtar,
      // updated_at: new Date().toISOString(),
    });
  },
});

import { defineSchema, defineTable } from 'convex/server';

export default defineSchema({
  projects: defineTable({
    name: 'string',
  }),

  projectProgress: defineTable({
    projectId: 'string', // Foreign key to `projects._id`
    progress: 'number',  // e.g. 0 to 100
  }).index('by_projectId', ['projectId']),
});

import { defineSchema, defineTable } from 'convex/server';

export default defineSchema({
  projects: defineTable({
    name: 'string',
  }),

  projectProgress: defineTable({
    projectId: 'string', // Foreign key to `projects._id`
    progress: 'number',  // e.g. 0 to 100
  }).index('by_projectId', ['projectId']),
});

// convex/queries/getProjectAndProgress.ts
import { query } from 'convex/server';
import { v } from 'convex/values';

export const getProjectAndProgress = query({
  args: { projectId: v.id('projects') },
  handler: async (ctx, { projectId }) => {
    const [project, progress] = await Promise.all([
      ctx.db.get(projectId),
      ctx.db
        .query('projectProgress')
        .withIndex('by_projectId', (q) => q.eq('projectId', projectId))
        .order('desc')
        .first(),
    ]);

    return {
      project,
      progress,
    };
});

// convex/queries/getProjectAndProgress.ts
import { query } from 'convex/server';
import { v } from 'convex/values';

export const getProjectAndProgress = query({
  args: { projectId: v.id('projects') },
  handler: async (ctx, { projectId }) => {
    const [project, progress] = await Promise.all([
      ctx.db.get(projectId),
      ctx.db
        .query('projectProgress')
        .withIndex('by_projectId', (q) => q.eq('projectId', projectId))
        .order('desc')
        .first(),
    ]);

    return {
      project,
      progress,
    };
});

import { v } from "convex/values";
import { authQuery } from "../../procedures";
import { internal } from "../../_generated/api";
import type { ReturnType } from './getTask';
import { internalQuery } from "../../_generated/server";
import { notEmpty } from "@utils/typescript.helpers";

type Result = Awaited<ReturnType>;

export type GetTasksReturnType = Result[];

const args = {
  projectId: v.optional(v.id("projects")),
  runIds: v.optional(v.array(v.string())),
  ids: v.optional(v.array(v.id('tasks'))),
  initialNumItems: v.optional(v.number()),
}

export const _internal = internalQuery({
  args,
  handler: async (ctx, args): Promise<Result[]> => {
    const project = args.projectId ? (await ctx.db.query("tasks")
      .withIndex("by_project_id", (q) => q.eq("projectId", args.projectId))
      .order("desc")
      .take(args.initialNumItems ?? 100)) : null;

    const ids = project?.map((t) => t._id) ?? args.ids;

    if (ids) return (await Promise.all(ids.map((id) => ctx.runQuery(internal.router.tasks.getTask._internal, { id }).catch(() => null)))).filter(notEmpty);
    if (args.runIds) return (await Promise.all(args.runIds.map((runId) => ctx.runQuery(internal.router.tasks.getTask._internal, { runId }).catch(() => null)))).filter(notEmpty);

    throw new Error("Please provide either a projectId, runIds or ids");
  }
})

export const authed = authQuery({
  args,
  handler: async (ctx, args): Promise<Result[]> => {
    return ctx.runQuery(internal.router.tasks.getTasks._internal, args)
  }
})

import { v } from "convex/values";
import { authQuery } from "../../procedures";
import { internal } from "../../_generated/api";
import type { ReturnType } from './getTask';
import { internalQuery } from "../../_generated/server";
import { notEmpty } from "@utils/typescript.helpers";

type Result = Awaited<ReturnType>;

export type GetTasksReturnType = Result[];

const args = {
  projectId: v.optional(v.id("projects")),
  runIds: v.optional(v.array(v.string())),
  ids: v.optional(v.array(v.id('tasks'))),
  initialNumItems: v.optional(v.number()),
}

export const _internal = internalQuery({
  args,
  handler: async (ctx, args): Promise<Result[]> => {
    const project = args.projectId ? (await ctx.db.query("tasks")
      .withIndex("by_project_id", (q) => q.eq("projectId", args.projectId))
      .order("desc")
      .take(args.initialNumItems ?? 100)) : null;

    const ids = project?.map((t) => t._id) ?? args.ids;

    if (ids) return (await Promise.all(ids.map((id) => ctx.runQuery(internal.router.tasks.getTask._internal, { id }).catch(() => null)))).filter(notEmpty);
    if (args.runIds) return (await Promise.all(args.runIds.map((runId) => ctx.runQuery(internal.router.tasks.getTask._internal, { runId }).catch(() => null)))).filter(notEmpty);

    throw new Error("Please provide either a projectId, runIds or ids");
  }
})

export const authed = authQuery({
  args,
  handler: async (ctx, args): Promise<Result[]> => {
    return ctx.runQuery(internal.router.tasks.getTasks._internal, args)
  }
})

import { publicQuery } from "../../../procedures";
import { COSTS } from "./credits.config";

export const unauth = publicQuery({
  args: {},
  handler: () => {
    return COSTS;
  }
})

import { publicQuery } from "../../../procedures";
import { COSTS } from "./credits.config";

export const unauth = publicQuery({
  args: {},
  handler: () => {
    return COSTS;
  }
})

const fooArgs = v.object({ bar: v.string() });

export const foo = query({ args: fooArgs, handler: fooHandler });

async function fooHandler(ctx: QueryCtx, args: Infer<typeof fooArgs>) {
  ...
}

const fooArgs = v.object({ bar: v.string() });

export const foo = query({ args: fooArgs, handler: fooHandler });

async function fooHandler(ctx: QueryCtx, args: Infer<typeof fooArgs>) {
  ...
}

const fooSpec = querySpec({
  args: { bar: v.string() },
  handler: async (ctx, args) => {...},
});

export const foo = query(fooSpec);

// somewhere else
await fooSpec.handler(ctx, { bar: "baz" });

const fooSpec = querySpec({
  args: { bar: v.string() },
  handler: async (ctx, args) => {...},
});

export const foo = query(fooSpec);

// somewhere else
await fooSpec.handler(ctx, { bar: "baz" });

export const getProfile = authQuery({
  args:{},
// helper
  handler: async (ctx) => getUserProfile(ctx, ctx.userId)
})

export const getUserProfile = publicQuery({
  args: { id: v.id("profile"), },
  handler: async (ctx, args) => getProfileByName(ctx, args.id)
})

export const getProfile = authQuery({
  args:{},
// helper
  handler: async (ctx) => getUserProfile(ctx, ctx.userId)
})

export const getUserProfile = publicQuery({
  args: { id: v.id("profile"), },
  handler: async (ctx, args) => getProfileByName(ctx, args.id)
})

// component
const images = usePaginatedQuery(api.router.storage.getImagesPaginated.authed, {}, { initialNumItems: 20 });
// [....]
images.loadMore(20);

// component
const images = usePaginatedQuery(api.router.storage.getImagesPaginated.authed, {}, { initialNumItems: 20 });
// [....]
images.loadMore(20);

import { paginationOptsValidator } from "convex/server";
import { authQuery } from "../../procedures";
import { getImage } from "../../functions/images";

export const authed = authQuery({
  args: { paginationOpts: paginationOptsValidator },
  handler: async (ctx, args) => {
    const workspaceId = ctx.user.currentWorkspaceId;
    const workspaceImages = await ctx.db.query("workspaceImages")
      .withIndex('by_workspace_id', q => q.eq('workspaceId', workspaceId))
      .order("desc")
      .paginate(args.paginationOpts)
//[...]

import { paginationOptsValidator } from "convex/server";
import { authQuery } from "../../procedures";
import { getImage } from "../../functions/images";

export const authed = authQuery({
  args: { paginationOpts: paginationOptsValidator },
  handler: async (ctx, args) => {
    const workspaceId = ctx.user.currentWorkspaceId;
    const workspaceImages = await ctx.db.query("workspaceImages")
      .withIndex('by_workspace_id', q => q.eq('workspaceId', workspaceId))
      .order("desc")
      .paginate(args.paginationOpts)
//[...]