Gabriel Brown
105 lines
3.0 KiB
TypeScript
105 lines
3.0 KiB
TypeScript
import { ConvexError, v } from 'convex/values';
|
|
|
|
import type { Doc } from './_generated/dataModel';
|
|
import { internalMutation, mutation, query } from './_generated/server';
|
|
import { getOwnedSpoon, getRequiredUserId } from './model';
|
|
|
|
const publicSecret = (secret: Doc<'spoonSecrets'>) => ({
|
|
_id: secret._id,
|
|
_creationTime: secret._creationTime,
|
|
spoonId: secret.spoonId,
|
|
ownerId: secret.ownerId,
|
|
name: secret.name,
|
|
valuePreview: secret.valuePreview,
|
|
description: secret.description,
|
|
createdAt: secret.createdAt,
|
|
updatedAt: secret.updatedAt,
|
|
});
|
|
|
|
export const listForSpoon = query({
|
|
args: { spoonId: v.id('spoons') },
|
|
handler: async (ctx, { spoonId }) => {
|
|
const ownerId = await getRequiredUserId(ctx);
|
|
await getOwnedSpoon(ctx, spoonId, ownerId);
|
|
const secrets = await ctx.db
|
|
.query('spoonSecrets')
|
|
.withIndex('by_spoon', (q) => q.eq('spoonId', spoonId))
|
|
.order('asc')
|
|
.collect();
|
|
return secrets.map(publicSecret);
|
|
},
|
|
});
|
|
|
|
export const remove = mutation({
|
|
args: { secretId: v.id('spoonSecrets') },
|
|
handler: async (ctx, { secretId }) => {
|
|
const ownerId = await getRequiredUserId(ctx);
|
|
const secret = await ctx.db.get(secretId);
|
|
if (secret?.ownerId !== ownerId) {
|
|
throw new ConvexError('Spoon secret not found.');
|
|
}
|
|
await ctx.db.delete(secretId);
|
|
return { success: true };
|
|
},
|
|
});
|
|
|
|
export const upsertEncryptedInternal = internalMutation({
|
|
args: {
|
|
spoonId: v.id('spoons'),
|
|
ownerId: v.id('users'),
|
|
name: v.string(),
|
|
encryptedValue: v.string(),
|
|
valuePreview: v.string(),
|
|
description: v.optional(v.string()),
|
|
},
|
|
handler: async (ctx, args) => {
|
|
const now = Date.now();
|
|
const existing = await ctx.db
|
|
.query('spoonSecrets')
|
|
.withIndex('by_name', (q) =>
|
|
q.eq('spoonId', args.spoonId).eq('name', args.name),
|
|
)
|
|
.first();
|
|
if (existing) {
|
|
if (existing.ownerId !== args.ownerId) {
|
|
throw new ConvexError('Spoon secret not found.');
|
|
}
|
|
await ctx.db.patch(existing._id, {
|
|
encryptedValue: args.encryptedValue,
|
|
valuePreview: args.valuePreview,
|
|
description: args.description,
|
|
updatedAt: now,
|
|
});
|
|
return existing._id;
|
|
}
|
|
return await ctx.db.insert('spoonSecrets', {
|
|
...args,
|
|
createdAt: now,
|
|
updatedAt: now,
|
|
});
|
|
},
|
|
});
|
|
|
|
export const patchEncryptedInternal = internalMutation({
|
|
args: {
|
|
secretId: v.id('spoonSecrets'),
|
|
ownerId: v.id('users'),
|
|
encryptedValue: v.optional(v.string()),
|
|
valuePreview: v.optional(v.string()),
|
|
description: v.optional(v.string()),
|
|
},
|
|
handler: async (ctx, args) => {
|
|
const secret = await ctx.db.get(args.secretId);
|
|
if (secret?.ownerId !== args.ownerId) {
|
|
throw new ConvexError('Spoon secret not found.');
|
|
}
|
|
await ctx.db.patch(args.secretId, {
|
|
encryptedValue: args.encryptedValue ?? secret.encryptedValue,
|
|
valuePreview: args.valuePreview ?? secret.valuePreview,
|
|
description: args.description,
|
|
updatedAt: Date.now(),
|
|
});
|
|
return { success: true };
|
|
},
|
|
});
|