11248318948

Committed 09 Oct 2024 04:36AM UTC coverage: 52.15%. Remained the same

Build # 11248318948

Build Type

push

github

Committed by

bcomnes

Commit Message

Schema store and more types

Run Details

215 of 468 branches covered (45.94%)

Branch coverage included in aggregate %.

571 of 589 new or added lines in 37 files covered. (96.94%)

93 existing lines in 18 files now uncovered.

8262 of 15787 relevant lines covered (52.33%)

0.79 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

39.59

/packages/web/routes/api/bookmarks/put-bookmarks.js

/* eslint-disable camelcase */

import SQL from '@nearform/sql'
import { oneLineTrim } from 'common-tags'
import { putTagsQuery } from '@breadcrum/resources/tags/put-tags-query.js'

import { createEpisode } from '../episodes/episode-query-create.js'
import { createArchive } from '../archives/archive-query-create.js'
import { getBookmarksQuery } from './get-bookmarks-query.js'
import { normalizeURL } from './normalizeURL.js'

/**
 * @import { FastifyPluginAsyncJsonSchemaToTs } from '@bret/type-provider-json-schema-to-ts'
 * @import { SchemaBookmarkCreate } from './schemas/schema-bookmark-create.js'
 * @import { SchemaBookmarkRead } from './schemas/schema-bookmark-read.js'
 * @import { SchemaEpisodeRead } from '../episodes/schemas/schema-episode-read.js'
 * @import { SchemaArchiveRead } from '../archives/schemas/schema-archive-read.js'
 * @import { TypeBookmarkWithArchivesAndEpisodes, SchemaBookmarkWithArchivesAndEpisodes } from './schemas/schema-bookmark-with-archives-and-episodes.js'
 */

/**
 * @type {FastifyPluginAsyncJsonSchemaToTs<
 *     {references: [
 *       SchemaBookmarkCreate,
 *       SchemaBookmarkRead,
 *       SchemaEpisodeRead,
 *       SchemaArchiveRead,
 *       SchemaBookmarkWithArchivesAndEpisodes
*     ],
*    deserialize: [{
*       pattern: {
*         type: "string"
*         format: "date-time"
*       }
*       output: Date
*     }]}
 * >}
 */
export async function putBookmarks (fastify, opts) {
  fastify.put(
    '/',
    {
      preHandler: fastify.auth([
        fastify.verifyJWT,
        fastify.notDisabled,
      ], {
        relation: 'and',
      }),
      schema: ({
        tags: ['bookmarks'],
        body: /** @type {SchemaBookmarkCreate} */ (fastify.getSchema('schema:breadcrum:bookmark:create')),
        querystring: {
          type: 'object',
          properties: {
            update: {
              type: 'boolean',
              default: false,
              description: oneLineTrim`
              If set to true, bookmarks that already exist at URL are redirected
              to to the specific bookmark endpoint which will process the
              request as a bookmark update. Otherwise, this creates or returns
              the existing bookmark.
            `,
            },
            meta: {
              type: 'boolean',
              default: false,
              description: 'Extract page metadata on the server.',
            },
            episode: {
              type: 'boolean',
              default: true,
              description: 'Determines if an episode is optimistically created',
            },
            archive: {
              type: 'boolean',
              default: true,
              description: 'Determines if an archive is optimistically created',
            },
            normalize: {
              type: 'boolean',
              default: true,
              description: 'Normalize URLs when looking them up or creating them.',
            },
          }
        },
        response: {
          201: {
            type: 'object',
            description: 'Newly created bookmarks are returned in full',
            properties: {
              status: { enum: ['created'] },
              site_url: { type: 'string' },
              data: {
                $ref: 'schema:breadcrum:bookmark-with-archives-and-episode',
              },
            },
          },
          200: {
            type: 'object',
            description: 'Existing bookmarks are returned unmodified',
            properties: {
              status: { enum: ['nochange'] },
              site_url: { type: 'string' },
              data: {
                $ref: 'schema:breadcrum:bookmark-with-archives-and-episode',
              },
            },
          },
        },
      }),
    },
    async function createBookmark (request, reply) {
      return fastify.pg.transact(async client => {
        const userId = request.user.id
        const {
          note,
          toread,
          sensitive,
          tags = [],
          archive_urls = [],
          summary,
        } = request.body
        let { url, title } = request.body
        const urlObj = new URL(url)

        const {
          update,
          meta,
          episode,
          archive,
          normalize,
        } = request.query

        if (normalize) { // This will be the one possibly slow step
          const { normalizedURL } = await normalizeURL(urlObj)
          url = normalizedURL
        }

        const checkForExistingQuery = getBookmarksQuery({
          ownerId: userId,
          url,
          sensitive: true,
          perPage: 1,
        })

        const existingResults = await client.query(checkForExistingQuery)
        /** @type {TypeBookmarkWithArchivesAndEpisodes | undefined} */
        const maybeResult = existingResults.rows[0]

        if (maybeResult) {
          if (update) {
            reply.redirect(`/api/bookmarks/${maybeResult.id}`, 308)
            return
          } else {
            reply.status(200)
            return {
              status: 'nochange',
              site_url: `${fastify.config.TRANSPORT}://${fastify.config.HOST}/bookmarks/b?id=${maybeResult.id}`,
              data: maybeResult,
            }
          }
        }

        // Title will fallback to just being the URL on create
        title = title ?? url

        const createBookmark = SQL`
        insert into bookmarks (
          url,
          title,
          note,
          toread,
          sensitive,
          archive_urls,
          summary,
          owner_id,
          done
        ) values (
          ${url},
          ${title ?? url ?? null},
          ${note ?? null},
          ${toread ?? false},
          ${sensitive ?? false},
          ${archive_urls.length > 0 ? archive_urls : SQL`'{}'`},
          ${summary ?? null},
          ${userId},
          ${meta === false}
        )
        returning id, url, title, toread, sensitive, archive_urls, owner_id;`

        const results = await client.query(createBookmark)
        const bookmark = results.rows[0]

        if (tags?.length > 0) {
          await putTagsQuery({
            fastify,
            pg: client,
            userId,
            bookmarkId: bookmark.id,
            tags,
          })
        }

        let episodeId, episodeMedium, episodeURL
        if (episode) {
          // TODO: ensure handling of createEpisode url is correct
          const episodeEntity = await createEpisode({
            client,
            userId,
            bookmarkId: bookmark.id,
            type: request?.body?.createEpisode?.type ?? 'redirect',
            medium: request?.body?.createEpisode?.medium ?? 'video',
            url: request?.body?.createEpisode?.url ?? url,
          })
          episodeId = episodeEntity.id
          episodeMedium = episodeEntity.medium
          episodeURL = episodeEntity.url

          await fastify.queues.resolveEpisodeQ.add(
            'resolve-episode',
            {
              userId,
              bookmarkTitle: bookmark.title,
              episodeId,
              url: episodeURL,
              medium: episodeMedium,
            }
          )
        }

        let archiveId, archiveURL
        if (archive) {
          // TODO: ensure handling of createArchive url is correct
          const archiveEntity = await createArchive({
            client,
            userId,
            bookmarkId: bookmark.id,
            bookmarkTitle: title ?? null,
            url: request?.body?.createArchive?.url ?? url,
            extractionMethod: 'server',
          })

          archiveId = archiveEntity.id
          archiveURL = archiveEntity.url
        }

        // Commit bookmark, tags, archive and episode in their incomplete state
        await client.query('commit')
        fastify.metrics.episodeCounter.inc()
        fastify.metrics.archiveCounter.inc()
        fastify.metrics.bookmarkCreatedCounter.inc()

        if (archive || meta) {
          await fastify.queues.resolveDocumentQ.add(
            'resolve-document',
            {
              url,
              userId,
              resolveMeta: meta,
              archive,
              title,
              tags,
              summary,
              bookmarkId: bookmark.id,
              archiveId,
              archiveURL,
            }
          )
        }

        // Look up the newly created bookmark instead of trying to re-assemble it here.
        const bookmarkQuery = getBookmarksQuery({
          ownerId: userId,
          url,
          sensitive: true,
          perPage: 1,
        })

        const createdResults = await fastify.pg.query(bookmarkQuery)
        const createdBookmark = createdResults.rows.pop()

        reply.status(201)
        return {
          status: 'ok',
          site_url: `${fastify.config.TRANSPORT}://${fastify.config.HOST}/bookmarks/b?id=${bookmark.id}`,
          data: createdBookmark,
        }
      })
    }
  )
}

1	/* eslint-disable camelcase */	1✔
2		1✔
3	import SQL from '@nearform/sql'	1✔
4	import { oneLineTrim } from 'common-tags'	1✔
5	import { putTagsQuery } from '@breadcrum/resources/tags/put-tags-query.js'	1✔
6		1✔
7	import { createEpisode } from '../episodes/episode-query-create.js'	1✔
8	import { createArchive } from '../archives/archive-query-create.js'	1✔
9	import { getBookmarksQuery } from './get-bookmarks-query.js'	1✔
10	import { normalizeURL } from './normalizeURL.js'	1✔
11		1✔
12	/**	1✔
13	* @import { FastifyPluginAsyncJsonSchemaToTs } from '@bret/type-provider-json-schema-to-ts'	1✔
14	* @import { SchemaBookmarkCreate } from './schemas/schema-bookmark-create.js'	1✔
15	* @import { SchemaBookmarkRead } from './schemas/schema-bookmark-read.js'	1✔
16	* @import { SchemaEpisodeRead } from '../episodes/schemas/schema-episode-read.js'	1✔
17	* @import { SchemaArchiveRead } from '../archives/schemas/schema-archive-read.js'	1✔
18	* @import { TypeBookmarkWithArchivesAndEpisodes, SchemaBookmarkWithArchivesAndEpisodes } from './schemas/schema-bookmark-with-archives-and-episodes.js'	1✔
19	*/	1✔
20		1✔
21	/**	1✔
22	* @type {FastifyPluginAsyncJsonSchemaToTs<	1✔
23	* {references: [	1✔
24	* SchemaBookmarkCreate,	1✔
25	* SchemaBookmarkRead,	1✔
26	* SchemaEpisodeRead,	1✔
27	* SchemaArchiveRead,	1✔
28	* SchemaBookmarkWithArchivesAndEpisodes	1✔
29	* ],	1✔
30	* deserialize: [{	1✔
31	* pattern: {	1✔
32	* type: "string"	1✔
33	* format: "date-time"	1✔
34	* }	1✔
35	* output: Date	1✔
36	* }]}	1✔
37	* >}	1✔
38	*/	1✔
39	export async function putBookmarks (fastify, opts) {	1✔
40	fastify.put(	2✔
41	'/',	2✔
42	{	2✔
43	preHandler: fastify.auth([	2✔
44	fastify.verifyJWT,	2✔
45	fastify.notDisabled,	2✔
46	], {	2✔
47	relation: 'and',	2✔
48	}),	2✔
49	schema: ({	2✔
50	tags: ['bookmarks'],	2✔
51	body: /** @type {SchemaBookmarkCreate} */ (fastify.getSchema('schema:breadcrum:bookmark:create')),	2✔
52	querystring: {	2✔
53	type: 'object',	2✔
54	properties: {	2✔
55	update: {	2✔
56	type: 'boolean',	2✔
57	default: false,	2✔
58	description: oneLineTrim`	2✔
59	If set to true, bookmarks that already exist at URL are redirected	2✔
60	to to the specific bookmark endpoint which will process the	2✔
61	request as a bookmark update. Otherwise, this creates or returns	2✔
62	the existing bookmark.	2✔
63	`,	2✔
64	},	2✔
65	meta: {	2✔
66	type: 'boolean',	2✔
67	default: false,	2✔
68	description: 'Extract page metadata on the server.',	2✔
69	},	2✔
70	episode: {	2✔
71	type: 'boolean',	2✔
72	default: true,	2✔
73	description: 'Determines if an episode is optimistically created',	2✔
74	},	2✔
75	archive: {	2✔
76	type: 'boolean',	2✔
77	default: true,	2✔
78	description: 'Determines if an archive is optimistically created',	2✔
79	},	2✔
80	normalize: {	2✔
81	type: 'boolean',	2✔
82	default: true,	2✔
83	description: 'Normalize URLs when looking them up or creating them.',	2✔
84	},	2✔
85	}	2✔
86	},	2✔
87	response: {	2✔
88	201: {	2✔
89	type: 'object',	2✔
90	description: 'Newly created bookmarks are returned in full',	2✔
91	properties: {	2✔
92	status: { enum: ['created'] },	2✔
93	site_url: { type: 'string' },	2✔
94	data: {	2✔
95	$ref: 'schema:breadcrum:bookmark-with-archives-and-episode',	2✔
96	},	2✔
97	},	2✔
98	},	2✔
99	200: {	2✔
100	type: 'object',	2✔
101	description: 'Existing bookmarks are returned unmodified',	2✔
102	properties: {	2✔
103	status: { enum: ['nochange'] },	2✔
104	site_url: { type: 'string' },	2✔
105	data: {	2✔
106	$ref: 'schema:breadcrum:bookmark-with-archives-and-episode',	2✔
107	},	2✔
108	},	2✔
109	},	2✔
110	},	2✔
111	}),	2✔
112	},	2✔
113	async function createBookmark (request, reply) {	2✔
114	return fastify.pg.transact(async client => {	×
115	const userId = request.user.id	×
116	const {	×
117	note,	×
118	toread,	×
119	sensitive,	×
120	tags = [],	×
121	archive_urls = [],	×
122	summary,	×
123	} = request.body	×
124	let { url, title } = request.body	×
125	const urlObj = new URL(url)	×
126		×
127	const {	×
128	update,	×
129	meta,	×
130	episode,	×
131	archive,	×
132	normalize,	×
133	} = request.query	×
134		×
135	if (normalize) { // This will be the one possibly slow step	×
136	const { normalizedURL } = await normalizeURL(urlObj)	×
137	url = normalizedURL	×
138	}	×
139		×
140	const checkForExistingQuery = getBookmarksQuery({	×
141	ownerId: userId,	×
142	url,	×
143	sensitive: true,	×
144	perPage: 1,	×
145	})	×
146		×
147	const existingResults = await client.query(checkForExistingQuery)	×
NEW 148	/** @type {TypeBookmarkWithArchivesAndEpisodes \| undefined} */	×
149	const maybeResult = existingResults.rows[0]	×
150		×
NEW 151	if (maybeResult) {	×
152	if (update) {	×
153	reply.redirect(`/api/bookmarks/${maybeResult.id}`, 308)	×
154	return	×
155	} else {	×
156	reply.status(200)	×
157	return {	×
158	status: 'nochange',	×
159	site_url: `${fastify.config.TRANSPORT}://${fastify.config.HOST}/bookmarks/b?id=${maybeResult.id}`,	×
160	data: maybeResult,	×
161	}	×
162	}	×
163	}	×
164		×
165	// Title will fallback to just being the URL on create	×
166	title = title ?? url	×
167		×
168	const createBookmark = SQL`	×
169	insert into bookmarks (	×
170	url,	×
171	title,	×
172	note,	×
173	toread,	×
174	sensitive,	×
175	archive_urls,	×
176	summary,	×
177	owner_id,	×
178	done	×
179	) values (	×
180	${url},	×
181	${title ?? url ?? null},	×
182	${note ?? null},	×
183	${toread ?? false},	×
184	${sensitive ?? false},	×
185	${archive_urls.length > 0 ? archive_urls : SQL`'{}'`},	×
186	${summary ?? null},	×
187	${userId},	×
188	${meta === false}	×
189	)	×
190	returning id, url, title, toread, sensitive, archive_urls, owner_id;`	×
191		×
192	const results = await client.query(createBookmark)	×
193	const bookmark = results.rows[0]	×
194		×
195	if (tags?.length > 0) {	×
196	await putTagsQuery({	×
197	fastify,	×
198	pg: client,	×
199	userId,	×
200	bookmarkId: bookmark.id,	×
201	tags,	×
202	})	×
203	}	×
204		×
205	let episodeId, episodeMedium, episodeURL	×
206	if (episode) {	×
207	// TODO: ensure handling of createEpisode url is correct	×
208	const episodeEntity = await createEpisode({	×
209	client,	×
210	userId,	×
211	bookmarkId: bookmark.id,	×
212	type: request?.body?.createEpisode?.type ?? 'redirect',	×
213	medium: request?.body?.createEpisode?.medium ?? 'video',	×
214	url: request?.body?.createEpisode?.url ?? url,	×
215	})	×
216	episodeId = episodeEntity.id	×
217	episodeMedium = episodeEntity.medium	×
218	episodeURL = episodeEntity.url	×
219		×
220	await fastify.queues.resolveEpisodeQ.add(	×
221	'resolve-episode',	×
222	{	×
223	userId,	×
224	bookmarkTitle: bookmark.title,	×
225	episodeId,	×
226	url: episodeURL,	×
227	medium: episodeMedium,	×
228	}	×
229	)	×
230	}	×
231		×
232	let archiveId, archiveURL	×
233	if (archive) {	×
234	// TODO: ensure handling of createArchive url is correct	×
235	const archiveEntity = await createArchive({	×
236	client,	×
237	userId,	×
238	bookmarkId: bookmark.id,	×
239	bookmarkTitle: title ?? null,	×
240	url: request?.body?.createArchive?.url ?? url,	×
241	extractionMethod: 'server',	×
242	})	×
243		×
244	archiveId = archiveEntity.id	×
245	archiveURL = archiveEntity.url	×
246	}	×
247		×
248	// Commit bookmark, tags, archive and episode in their incomplete state	×
249	await client.query('commit')	×
250	fastify.metrics.episodeCounter.inc()	×
251	fastify.metrics.archiveCounter.inc()	×
252	fastify.metrics.bookmarkCreatedCounter.inc()	×
253		×
254	if (archive \|\| meta) {	×
255	await fastify.queues.resolveDocumentQ.add(	×
256	'resolve-document',	×
257	{	×
258	url,	×
259	userId,	×
260	resolveMeta: meta,	×
261	archive,	×
262	title,	×
263	tags,	×
264	summary,	×
265	bookmarkId: bookmark.id,	×
266	archiveId,	×
267	archiveURL,	×
268	}	×
269	)	×
270	}	×
271		×
272	// Look up the newly created bookmark instead of trying to re-assemble it here.	×
273	const bookmarkQuery = getBookmarksQuery({	×
274	ownerId: userId,	×
275	url,	×
276	sensitive: true,	×
277	perPage: 1,	×
278	})	×
279		×
280	const createdResults = await fastify.pg.query(bookmarkQuery)	×
281	const createdBookmark = createdResults.rows.pop()	×
282		×
283	reply.status(201)	×
284	return {	×
285	status: 'ok',	×
UNCOV 286	site_url: `${fastify.config.TRANSPORT}://${fastify.config.HOST}/bookmarks/b?id=${bookmark.id}`,	×
UNCOV 287	data: createdBookmark,	×
UNCOV 288	}	×
UNCOV 289	})	×
UNCOV 290	}	×
291	)	2✔
292	}	2✔

hifiwi-fi / breadcrum.net / 11248318948

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous