nocobase/nocobase

[Credential-related source omitted]

Executable file

Executable file

Executable file

Executable file

Executable file

Executable file

Executable file

Executable file

Executable file

Executable file

Executable file

Executable file

Executable file

Executable file

Executable file

headers: {     'content-type': 'application/json',     origin: 'http://localhost',

'content-type': 'application/json',     origin: 'http://localhost',     'Idempotency-Key': `${Date.now()}.${randomUUID()}`,

origin: 'http://localhost',

},         });         const response = await session.fetch('/onboarding', write(complete));

});         const response = await session.fetch('/onboarding', write(complete));         expect(response.status).toBe(200);

const response = await session.fetch('/onboarding', write(complete));

).toBe(1);     const detail = (       await (await view.session.fetch(`/onboarding/${id!}`)).json()

const detail = (       await (await view.session.fetch(`/onboarding/${id!}`)).json()     ).data as OnboardingDetail;

await (await view.session.fetch(`/onboarding/${id!}`)).json()

Executable file

Executable file

Executable file

config: {     logging: { enabled: false },     app: { publicOrigin: 'http://localhost' },

logging: { enabled: false },     app: { publicOrigin: 'http://localhost' },     auth: {

app: { publicOrigin: 'http://localhost' },

headers: {     'content-type': 'application/json',     origin: 'http://localhost',

'content-type': 'application/json',     origin: 'http://localhost',     'Idempotency-Key': key,

origin: 'http://localhost',

session = users.owner,     key?: string,   ) => session.fetch('/onboarding', write(body, 'POST', key));

key?: string,   ) => session.fetch('/onboarding', write(body, 'POST', key));   const get = async (

) => session.fetch('/onboarding', write(body, 'POST', key));

session = users.owner,   ): Promise<OnboardingDetail> =>     (await (await session.fetch(`/onboarding/${id}`)).json()).data;

): Promise<OnboardingDetail> =>     (await (await session.fetch(`/onboarding/${id}`)).json()).data;   const submit = async (

(await (await session.fetch(`/onboarding/${id}`)).json()).data;

key?: string,   ) =>     session.fetch(

) =>     session.fetch(       `/onboarding/${id}/fire`,

session.fetch(

] as const)     expect((await app.request(url, init)).status).toBe(401);   expect((await f.users.member.fetch('/onboarding')).status).toBe(403);

expect((await app.request(url, init)).status).toBe(401);   expect((await f.users.member.fetch('/onboarding')).status).toBe(403);   expect(

expect((await f.users.member.fetch('/onboarding')).status).toBe(403);

expect(     (await f.users.viewer.fetch('/onboarding/candidates?kind=departments'))       .status,

(await f.users.viewer.fetch('/onboarding/candidates?kind=departments'))

const version = (await f.get(id)).record.lifecycleVersion;   const administrator = await signIn(app, DEFAULT_ADMIN_CREDENTIALS);   expect((await administrator.fetch(`/onboarding/${id}`)).status).toBe(404);

const administrator = await signIn(app, DEFAULT_ADMIN_CREDENTIALS);   expect((await administrator.fetch(`/onboarding/${id}`)).status).toBe(404);   for (const name of ['other', 'viewer']) {

expect((await administrator.fetch(`/onboarding/${id}`)).status).toBe(404);

for (const name of ['other', 'viewer']) {     expect((await f.users[name].fetch(`/onboarding/${id}`)).status).toBe(404);     expect(

expect((await f.users[name].fetch(`/onboarding/${id}`)).status).toBe(404);

expect(       (         await f.users[name].fetch(

(         await f.users[name].fetch(           `/onboarding/${id}`,

await f.users[name].fetch(

);     expect(       (await (await f.users[name].fetch('/onboarding')).json()).data,

expect(       (await (await f.users[name].fetch('/onboarding')).json()).data,     ).toEqual([]);

(await (await f.users[name].fetch('/onboarding')).json()).data,

expect(       (         await f.users.owner.fetch(

(         await f.users.owner.fetch(           '/onboarding',

await f.users.owner.fetch(

expect(     (       await f.users.owner.fetch(

(       await f.users.owner.fetch(         `/onboarding/${id}`,

await f.users.owner.fetch(

(       await (         await f.users.viewer.fetch('/onboarding?status=submitted&q=Example')

await (         await f.users.viewer.fetch('/onboarding?status=submitted&q=Example')       ).json()

await f.users.viewer.fetch('/onboarding?status=submitted&q=Example')

(         await (           await f.users.owner.fetch('/onboarding/candidates?kind=departments')

await (           await f.users.owner.fetch('/onboarding/candidates?kind=departments')         ).json()

await f.users.owner.fetch('/onboarding/candidates?kind=departments')

expect(     (       await f.users.owner.fetch(

(       await f.users.owner.fetch(         `/onboarding/${id}`,

await f.users.owner.fetch(

expect(     (       await f.users.owner.fetch(

(       await f.users.owner.fetch(         `/onboarding/${id}`,

await f.users.owner.fetch(

).toBe('true');   expect(     (await f.users.owner.fetch(`/onboarding/${id}`, write(update, 'PATCH')))

expect(     (await f.users.owner.fetch(`/onboarding/${id}`, write(update, 'PATCH')))       .status,

(await f.users.owner.fetch(`/onboarding/${id}`, write(update, 'PATCH')))

expect(     (       await f.users.owner.fetch(

(       await f.users.owner.fetch(         `/onboarding/${id}`,

await f.users.owner.fetch(

const editRace = await Promise.all([     f.submit(editId, editVersion),     f.users.owner.fetch(

f.submit(editId, editVersion),     f.users.owner.fetch(       `/onboarding/${editId}`,

f.users.owner.fetch(

expect(       (         await f.users.owner.fetch(

(         await f.users.owner.fetch(           `/onboarding/${id}`,

await f.users.owner.fetch(

Executable file

Executable file

Executable file

Executable file

Executable file

Executable file

Executable file

Executable file

Executable file

Executable file

Executable file

Executable file

Executable file

Executable file

Executable file

headers: {         'content-type': 'application/json',         origin: 'http://localhost',

'content-type': 'application/json',         origin: 'http://localhost',         'Idempotency-Key': `${Date.now()}.${randomUUID()}`,

origin: 'http://localhost',

const detail = async () =>       (         (await (await owner.fetch(`/procurement/${id}`)).json()) as {

(         (await (await owner.fetch(`/procurement/${id}`)).json()) as {           data: ProcurementDetail;

(await (await owner.fetch(`/procurement/${id}`)).json()) as {

expect(         (           await reviewer.fetch(

(           await reviewer.fetch(             `/procurement/${id}/fire`,

await reviewer.fetch(

},           });           const created = await owner.fetch(

});           const created = await owner.fetch(             '/procurement',

const created = await owner.fetch(

expect(             (               await owner.fetch(

(               await owner.fetch(                 `/procurement/${id}/fire`,

await owner.fetch(

expect(           (             await owner!.fetch(

(             await owner!.fetch(               `/procurement/${id!}`,

await owner!.fetch(

Executable file

Executable file

await owner.route(detailApi, async (route) => {       if (route.request().method() !== 'GET') return route.continue();       const response = await route.fetch();

if (route.request().method() !== 'GET') return route.continue();       const response = await route.fetch();       refreshStarted.resolve();

const response = await route.fetch();

Executable file

config: {     logging: { enabled: false },     app: { publicOrigin: 'http://localhost' },

logging: { enabled: false },     app: { publicOrigin: 'http://localhost' },     auth: {

app: { publicOrigin: 'http://localhost' },

headers: {     'content-type': 'application/json',     origin: 'http://localhost',

'content-type': 'application/json',     origin: 'http://localhost',     'Idempotency-Key': key,

origin: 'http://localhost',

};   const create = async (body = input, session = users.owner, key?: string) =>     session.fetch('/procurement', write(body, 'POST', key));

const create = async (body = input, session = users.owner, key?: string) =>     session.fetch('/procurement', write(body, 'POST', key));   const get = async (id: string, session = users.owner) =>

session.fetch('/procurement', write(body, 'POST', key));

const get = async (id: string, session = users.owner) =>     (       (await (await session.fetch(`/procurement/${id}`)).json()) as {

(       (await (await session.fetch(`/procurement/${id}`)).json()) as {         data: ProcurementDetail;

(await (await session.fetch(`/procurement/${id}`)).json()) as {

requestId = randomUUID(),   ) =>     session.fetch(

) =>     session.fetch(       `/procurement/${id}/fire`,

session.fetch(

const f = await fixture(testApp);   expect((await testApp.request('/procurement')).status).toBe(401);   expect((await f.users.member.fetch('/procurement')).status).toBe(403);

expect((await testApp.request('/procurement')).status).toBe(401);   expect((await f.users.member.fetch('/procurement')).status).toBe(403);   expect(

expect((await f.users.member.fetch('/procurement')).status).toBe(403);

expect(     (await f.users.member.fetch('/procurement?status=invalid')).status,   ).toBe(403);

(await f.users.member.fetch('/procurement?status=invalid')).status,

).toBe(403);   expect((await f.users.member.fetch('/procurement', write({}))).status).toBe(     403,

expect((await f.users.member.fetch('/procurement', write({}))).status).toBe(

);   expect(     (await f.users.reviewer.fetch('/procurement/candidates?kind=materials'))

expect(     (await f.users.reviewer.fetch('/procurement/candidates?kind=materials'))       .status,

(await f.users.reviewer.fetch('/procurement/candidates?kind=materials'))

).toBe(403);   expect(     (await f.users.reviewer.fetch('/procurement/candidates?kind=invalid'))

expect(     (await f.users.reviewer.fetch('/procurement/candidates?kind=invalid'))       .status,

(await f.users.reviewer.fetch('/procurement/candidates?kind=invalid'))

const id = (await (await f.create()).json()).data.id;   for (const actor of ['other', 'reviewer', 'otherReviewer', 'member'])     expect((await f.users[actor].fetch(`/procurement/${id}`)).status).toBe(

for (const actor of ['other', 'reviewer', 'otherReviewer', 'member'])     expect((await f.users[actor].fetch(`/procurement/${id}`)).status).toBe(       actor === 'member' ? 403 : 404,

expect((await f.users[actor].fetch(`/procurement/${id}`)).status).toBe(

);   expect(     (await (await f.users.other.fetch('/procurement')).json()).data,

expect(     (await (await f.users.other.fetch('/procurement')).json()).data,   ).toEqual([]);

(await (await f.users.other.fetch('/procurement')).json()).data,

expect(       (         await f.users.owner.fetch(

(         await f.users.owner.fetch(           '/procurement',

await f.users.owner.fetch(

expect(     (       await f.users.owner.fetch(

(       await f.users.owner.fetch(         `/procurement/${id}`,

await f.users.owner.fetch(

}   const candidates = await (     await f.users.owner.fetch(

const candidates = await (     await f.users.owner.fetch(       '/procurement/candidates?kind=materials&q=Note&active=true',

await f.users.owner.fetch(

(       await (         await f.users.owner.fetch(

await (         await f.users.owner.fetch(           '/procurement/candidates?kind=suppliers&q=Restricted',

await f.users.owner.fetch(

(       await (         await f.users.owner.fetch(

await (         await f.users.owner.fetch(           '/procurement/candidates?kind=materials&active=false',

await f.users.owner.fetch(

expect(     (       await f.users.other.fetch(

(       await f.users.other.fetch(         `/procurement/${id}`,

await f.users.other.fetch(

(       await (         await f.users.owner.fetch(

await (         await f.users.owner.fetch(           '/procurement?q=Office&status=submitted&pageSize=1',

await f.users.owner.fetch(

).toMatchObject({ total: 1, pageSize: 1 });   expect(     (await (await f.users.owner.fetch('/procurement?status=draft')).json())

expect(     (await (await f.users.owner.fetch('/procurement?status=draft')).json())       .data,

(await (await f.users.owner.fetch('/procurement?status=draft')).json())

expect(     (       await f.users.owner.fetch(

(       await f.users.owner.fetch(         `/procurement/${id}`,

await f.users.owner.fetch(

expect(     (       await f.users.owner.fetch(

(       await f.users.owner.fetch(         `/procurement/${id}`,

await f.users.owner.fetch(

expect(     (       await f.users.owner.fetch(

(       await f.users.owner.fetch(         `/procurement/${id}`,

await f.users.owner.fetch(

]);   expect(submissions.filter((r) => r.ok)).toHaveLength(1);   const stale = await f.users.owner.fetch(

expect(submissions.filter((r) => r.ok)).toHaveLength(1);   const stale = await f.users.owner.fetch(     `/procurement/${id}`,

const stale = await f.users.owner.fetch(

})),   });   const response = await f.users.owner.fetch(

});   const response = await f.users.owner.fetch(     '/procurement/candidates?kind=reviewers',

const response = await f.users.owner.fetch(

expect(       (         await f.users.owner.fetch(

(         await f.users.owner.fetch(           `/procurement/${id}`,

await f.users.owner.fetch(

Executable file

Executable file

Executable file

Executable file

Executable file

Executable file

Executable file

Executable file

Executable file

Executable file

Executable file

Executable file

Executable file

Executable file

Executable file

Executable file

Executable file

connections: ['main', 'analytics'],   config: {     app: { publicOrigin: 'http://localhost' },

config: {     app: { publicOrigin: 'http://localhost' },     auth: {

app: { publicOrigin: 'http://localhost' },

[Credential-related source omitted]

[Credential-related source omitted]

trustedOrigins: ['http://localhost'],

const write = (body: unknown, method = 'POST'): RequestInit => ({   method,   headers: { 'content-type': 'application/json', origin: 'http://localhost' },

method,   headers: { 'content-type': 'application/json', origin: 'http://localhost' },   body: JSON.stringify(body),

headers: { 'content-type': 'application/json', origin: 'http://localhost' },

test.beforeEach(async ({ testApp }) => {   const admin = await signIn(testApp, DEFAULT_ADMIN_CREDENTIALS);   const reset = await admin.fetch(`${prefix}/reset`, write({}));

const admin = await signIn(testApp, DEFAULT_ADMIN_CREDENTIALS);   const reset = await admin.fetch(`${prefix}/reset`, write({}));   if (reset.status !== 200) throw new Error('Example reset failed');

const reset = await admin.fetch(`${prefix}/reset`, write({}));

const manager = await signIn(testApp, credentials('manager'));   for (const page of [1, 2]) {     const result = await rep.fetch(

for (const page of [1, 2]) {     const result = await rep.fetch(       `${prefix}/customers/options?page=${page}&pageSize=10`,

const result = await rep.fetch(

);   }   const searched = await rep.fetch(

}   const searched = await rep.fetch(     `${prefix}/customers/options?search=aCoRn&status=active&pageSize=20`,

const searched = await rep.fetch(

});   expect(     (await rep.fetch(`${prefix}/customers/options?pageSize=21`)).status,

expect(     (await rep.fetch(`${prefix}/customers/options?pageSize=21`)).status,   ).toBe(400);

(await rep.fetch(`${prefix}/customers/options?pageSize=21`)).status,

).toBe(400);   expect((await rep.fetch(`${prefix}/customers/customer-21`)).status).toBe(403);   expect((await rep.fetch(`${prefix}/customers/missing`)).status).toBe(403);

expect((await rep.fetch(`${prefix}/customers/customer-21`)).status).toBe(403);

expect((await rep.fetch(`${prefix}/customers/missing`)).status).toBe(403);

expect(     await (await rep.fetch(`${prefix}/salesReps/options`)).json(),   ).toMatchObject({ data: [{ id: 'crm-rep' }], meta: { total: 1 } });

await (await rep.fetch(`${prefix}/salesReps/options`)).json(),

expect(     await (       await manager.fetch(`${prefix}/salesReps/options?search=aLeX`)

await (       await manager.fetch(`${prefix}/salesReps/options?search=aLeX`)     ).json(),

await manager.fetch(`${prefix}/salesReps/options?search=aLeX`)

meta: { total: 1 },   });   expect((await rep.fetch(`${prefix}/salesReps/crm-colleague`)).status).toBe(

});   expect((await rep.fetch(`${prefix}/salesReps/crm-colleague`)).status).toBe(     403,

expect((await rep.fetch(`${prefix}/salesReps/crm-colleague`)).status).toBe(

};   expect(     (await rep.fetch(`${prefix}/contacts/contact-01`, write(contact, 'PATCH')))

expect(     (await rep.fetch(`${prefix}/contacts/contact-01`, write(contact, 'PATCH')))       .status,

(await rep.fetch(`${prefix}/contacts/contact-01`, write(contact, 'PATCH')))

expect(     (       await rep.fetch(

(       await rep.fetch(         `${prefix}/contacts/contact-01`,

await rep.fetch(

).toBe(403);   expect(     (await rep.fetch(`${prefix}/contacts/contact-21`, write(contact, 'PATCH')))

expect(     (await rep.fetch(`${prefix}/contacts/contact-21`, write(contact, 'PATCH')))       .status,

(await rep.fetch(`${prefix}/contacts/contact-21`, write(contact, 'PATCH')))

.status,   ).toBe(403);   expect((await rep.fetch(`${prefix}/contacts/contact-21`)).status).toBe(403);

).toBe(403);   expect((await rep.fetch(`${prefix}/contacts/contact-21`)).status).toBe(403);   expect(

expect((await rep.fetch(`${prefix}/contacts/contact-21`)).status).toBe(403);

expect(     (       await rep.fetch(

(       await rep.fetch(         `${prefix}/contacts`,

await rep.fetch(

expect(     (       await rep.fetch(

(       await rep.fetch(         `${prefix}/contacts`,

await rep.fetch(

).status,   ).toBe(409);   const created = await rep.fetch(`${prefix}/contacts`, write(contact));

).toBe(409);   const created = await rep.fetch(`${prefix}/contacts`, write(contact));   expect(created.status).toBe(201);

const created = await rep.fetch(`${prefix}/contacts`, write(contact));

expect(     (       await rep.fetch(`${prefix}/contacts/${saved.id}`, {

(       await rep.fetch(`${prefix}/contacts/${saved.id}`, {         method: 'DELETE',

await rep.fetch(`${prefix}/contacts/${saved.id}`, {

method: 'DELETE',         headers: { origin: 'http://localhost' },       })

headers: { origin: 'http://localhost' },

expect(     (       await rep.fetch(`${prefix}/contacts/contact-21`, {

(       await rep.fetch(`${prefix}/contacts/contact-21`, {         method: 'DELETE',

await rep.fetch(`${prefix}/contacts/contact-21`, {

method: 'DELETE',         headers: { origin: 'http://localhost' },       })

headers: { origin: 'http://localhost' },

expect(     (       await manager.fetch(

(       await manager.fetch(         `${prefix}/customers/customer-01`,

await manager.fetch(

).status,   ).toBe(200);   expect((await rep.fetch(`${prefix}/customers/customer-01`)).status).toBe(403);

).toBe(200);   expect((await rep.fetch(`${prefix}/customers/customer-01`)).status).toBe(403);   expect((await rep.fetch(`${prefix}/contacts/contact-01`)).status).toBe(200); // Moved to another still-owned customer.

expect((await rep.fetch(`${prefix}/customers/customer-01`)).status).toBe(403);

expect((await rep.fetch(`${prefix}/contacts/contact-01`)).status).toBe(200); // Moved to another still-owned customer.

]) {     expect(       (await manager.fetch(`${prefix}/customers/batchUpdate`, batch(values)))

expect(       (await manager.fetch(`${prefix}/customers/batchUpdate`, batch(values)))         .status,

(await manager.fetch(`${prefix}/customers/batchUpdate`, batch(values)))

expect(     (       await manager.fetch(

(       await manager.fetch(         `${prefix}/customers/batchUpdate`,

await manager.fetch(

for (const ownerId of ['crm-colleague', 'crm-inactive', 'missing']) {     expect(       (await rep.fetch(`${prefix}/customers/batchUpdate`, batch({ ownerId })))

expect(       (await rep.fetch(`${prefix}/customers/batchUpdate`, batch({ ownerId })))         .status,

(await rep.fetch(`${prefix}/customers/batchUpdate`, batch({ ownerId })))

expect(       (         await rep.fetch(

(         await rep.fetch(           `${prefix}/customers/customer-01`,

await rep.fetch(

expect(       (         await manager.fetch(

(         await manager.fetch(           `${prefix}/customers/batchUpdate`,

await manager.fetch(

await repository.findOne({ filter: { id: 'customer-01' } }),   ).toMatchObject({ name: 'Acorn 01', status: 'paused', ownerId: 'crm-rep' });   const mixed = await rep.fetch(

).toMatchObject({ name: 'Acorn 01', status: 'paused', ownerId: 'crm-rep' });   const mixed = await rep.fetch(     `${prefix}/customers/batchUpdate`,

const mixed = await rep.fetch(

expect(     (       await rep.fetch(

(       await rep.fetch(         `${prefix}/customers/customer-21`,

await rep.fetch(

expect(     (       await rep.fetch(

(       await rep.fetch(         `${prefix}/customers/customer-10`,

await rep.fetch(

).status,   ).toBe(409);   const success = await manager.fetch(

).toBe(409);   const success = await manager.fetch(     `${prefix}/customers/batchUpdate`,

const success = await manager.fetch(

ownerId: 'crm-colleague',     });   expect((await rep.fetch(`${prefix}/reset`, write({}))).status).toBe(403);

});   expect((await rep.fetch(`${prefix}/reset`, write({}))).status).toBe(403);   const admin = await signIn(testApp, DEFAULT_ADMIN_CREDENTIALS);

expect((await rep.fetch(`${prefix}/reset`, write({}))).status).toBe(403);

const admin = await signIn(testApp, DEFAULT_ADMIN_CREDENTIALS);   expect((await admin.fetch(`${prefix}/reset`, write({}))).status).toBe(200);   expect(

expect((await admin.fetch(`${prefix}/reset`, write({}))).status).toBe(200);

],   });   expect((await rep.fetch(`${prefix}/customers`)).status).toBe(403);

});   expect((await rep.fetch(`${prefix}/customers`)).status).toBe(403);   expect(

expect((await rep.fetch(`${prefix}/customers`)).status).toBe(403);

expect(     (       await rep.fetch(

(       await rep.fetch(         `${prefix}/customers/batchUpdate`,

await rep.fetch(

grants: actionOnly,   });   expect((await rep.fetch(`${prefix}/customers`)).status).toBe(200);

});   expect((await rep.fetch(`${prefix}/customers`)).status).toBe(200);   await authz.permissionSets.update('crm-rep', {

expect((await rep.fetch(`${prefix}/customers`)).status).toBe(200);

Executable file

Executable file

Executable file

Executable file

Executable file

Executable file

Executable file

Executable file

Executable file

connections: ['main', 'analytics'],   config: {     app: { publicOrigin: 'http://localhost' },

config: {     app: { publicOrigin: 'http://localhost' },     auth: {

app: { publicOrigin: 'http://localhost' },

[Credential-related source omitted]

[Credential-related source omitted]

trustedOrigins: ['http://localhost'],

headers: {     'content-type': 'application/json',     origin: 'http://localhost',

'content-type': 'application/json',     origin: 'http://localhost',     'Idempotency-Key': operationKey,

origin: 'http://localhost',

headers: {           'content-type': 'application/json',           origin: 'http://localhost',

'content-type': 'application/json',           origin: 'http://localhost',         },

origin: 'http://localhost',

).toBe(200);   const denied = await signIn(testApp, member);   expect((await denied.fetch('/skillProjects')).status).toBe(403);

const denied = await signIn(testApp, member);   expect((await denied.fetch('/skillProjects')).status).toBe(403);   expect((await denied.fetch('/skillProjects', write('Denied'))).status).toBe(

expect((await denied.fetch('/skillProjects')).status).toBe(403);

expect((await denied.fetch('/skillProjects', write('Denied'))).status).toBe(

);   expect((await request('/example')).status).toBe(200);   expect((await admin.fetch('/skillProjects', write('   '))).status).toBe(400);

expect((await request('/example')).status).toBe(200);   expect((await admin.fetch('/skillProjects', write('   '))).status).toBe(400);   expect(

expect((await admin.fetch('/skillProjects', write('   '))).status).toBe(400);

expect(     (await admin.fetch('/skillProjects', write('a'.repeat(101)))).status,   ).toBe(400);

(await admin.fetch('/skillProjects', write('a'.repeat(101)))).status,

).toBe(400);   const operation = key();   const created = await admin.fetch(

const operation = key();   const created = await admin.fetch(     '/skillProjects',

const created = await admin.fetch(

const body = (await created.json()) as { data: { id: string; name: string } };   expect(body.data.name).toBe('Alpha');   const replay = await admin.fetch(

expect(body.data.name).toBe('Alpha');   const replay = await admin.fetch(     '/skillProjects',

const replay = await admin.fetch(

expect(await replay.json()).toEqual(body);   expect(     (await admin.fetch('/skillProjects', write('Different', 'POST', operation)))

expect(     (await admin.fetch('/skillProjects', write('Different', 'POST', operation)))       .status,

(await admin.fetch('/skillProjects', write('Different', 'POST', operation)))

expect(await testApp.connection.repository('skillProjects').count()).toBe(1);   const path = `/skillProjects/${body.data.id}`;   expect((await denied.fetch(path, write('Denied edit', 'PATCH'))).status).toBe(

const path = `/skillProjects/${body.data.id}`;   expect((await denied.fetch(path, write('Denied edit', 'PATCH'))).status).toBe(     403,

expect((await denied.fetch(path, write('Denied edit', 'PATCH'))).status).toBe(

403,   );   expect((await admin.fetch(path, write('Beta', 'PATCH'))).status).toBe(200);

);   expect((await admin.fetch(path, write('Beta', 'PATCH'))).status).toBe(200);   expect(await (await admin.fetch(path)).json()).toMatchObject({

expect((await admin.fetch(path, write('Beta', 'PATCH'))).status).toBe(200);

expect(await (await admin.fetch(path)).json()).toMatchObject({

.findOne({ filter: { id: body.data.id } }),   ).toMatchObject({ name: 'Beta' });   expect(await (await admin.fetch('/skillProjects')).json()).toMatchObject({

).toMatchObject({ name: 'Beta' });   expect(await (await admin.fetch('/skillProjects')).json()).toMatchObject({     data: [{ id: body.data.id, name: 'Beta' }],

expect(await (await admin.fetch('/skillProjects')).json()).toMatchObject({

meta: { total: 1 },   });   expect((await admin.fetch(`/skillProjects/${randomUUID()}`)).status).toBe(

});   expect((await admin.fetch(`/skillProjects/${randomUUID()}`)).status).toBe(     404,

expect((await admin.fetch(`/skillProjects/${randomUUID()}`)).status).toBe(

expect(     (       await admin.fetch(

(       await admin.fetch(         `/skillProjects/${randomUUID()}`,

await admin.fetch(

const boundary = '项'.repeat(100);   expect(     (await admin.fetch(path, write(` ${boundary} `, 'PATCH'))).status,

expect(     (await admin.fetch(path, write(` ${boundary} `, 'PATCH'))).status,   ).toBe(200);

(await admin.fetch(path, write(` ${boundary} `, 'PATCH'))).status,

).toBe(200);   expect(     (await admin.fetch(path, write('项'.repeat(101), 'PATCH'))).status,

expect(     (await admin.fetch(path, write('项'.repeat(101), 'PATCH'))).status,   ).toBe(400);

(await admin.fetch(path, write('项'.repeat(101), 'PATCH'))).status,

).toBe(400);   expect(await (await admin.fetch(path)).json()).toMatchObject({     data: { name: boundary },

expect(await (await admin.fetch(path)).json()).toMatchObject({

.repository('skillProjects')         .createOne({ values: { id: randomUUID(), name: `Project ${total}` } });     const response = (await (await admin.fetch('/skillProjects')).json()) as {

.createOne({ values: { id: randomUUID(), name: `Project ${total}` } });     const response = (await (await admin.fetch('/skillProjects')).json()) as {       data: { id: string }[];

const response = (await (await admin.fetch('/skillProjects')).json()) as {

}) => {   const admin = await signIn(testApp, DEFAULT_ADMIN_CREDENTIALS);   const created = await admin.fetch('/skillProjects', write('Original'));

const admin = await signIn(testApp, DEFAULT_ADMIN_CREDENTIALS);   const created = await admin.fetch('/skillProjects', write('Original'));   const { data: project } = (await created.json()) as { data: { id: string } };

const created = await admin.fetch('/skillProjects', write('Original'));

expect(     (await admin.fetch(path, write('Committed', 'PATCH', committedKey))).status,

(await admin.fetch(path, write('Committed', 'PATCH', committedKey))).status,

.repository('skillProjects')     .deleteOne({ filter: { id: project.id } });   const committed = await admin.fetch(

.deleteOne({ filter: { id: project.id } });   const committed = await admin.fetch(     path,

const committed = await admin.fetch(

const notAppliedKey = key();   const notApplied = await admin.fetch(

const notApplied = await admin.fetch(

.repository('skillProjects')     .createOne({ values: { id: project.id, name: 'Replacement' } });   const delayed = await admin.fetch(

.createOne({ values: { id: project.id, name: 'Replacement' } });   const delayed = await admin.fetch(     path,

const delayed = await admin.fetch(

error: { reason: 'PROJECT_UPDATE_NOT_APPLIED' },   });   expect(await (await admin.fetch(path)).json()).toMatchObject({

});   expect(await (await admin.fetch(path)).json()).toMatchObject({     data: { name: 'Replacement' },

expect(await (await admin.fetch(path)).json()).toMatchObject({

});   expect(     (await admin.fetch(path, write('Changed payload', 'PATCH', notAppliedKey)))

expect(     (await admin.fetch(path, write('Changed payload', 'PATCH', notAppliedKey)))       .status,

(await admin.fetch(path, write('Changed payload', 'PATCH', notAppliedKey)))

`better-sqlite3` is recorded as `false`: it loads the prebuilt binary it ships for Linux (glibc and musl), macOS and Windows on x64 and arm64, so it needs no build and installs without a C++ toolchain. On any other platform it fails with `C

Treat `/main` in examples as a default, never as a fixed route. Local `APP_BASE_PATH` resolves from the command-line environment, then `.env.local`, then `.env`, with `/main` as the fallback. Determine the remote application's actual public

For local client debugging against another running application, use `PROXY_TARGET_URL=<remote-application-base-url> pnpm dev` (for example, `https://backend.example.com/main`, without `/api`). This starts Vite, proxies API and WebSocket pat

| Source and reviewed revision                                                                                                                                                                                                                  

| ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

| [shadcn/ui design-system guidance](https://github.com/shadcn-ui/ui/blob/96da9cc7f1aa10580a3741664e2a77c721206c00/skills/shadcn/design-system.md) and [component showcase guidance](https://github.com/shadcn-ui/ui/blob/96da9cc7f1aa10580a3741

| [UI UX Pro Max](https://github.com/nextlevelbuilder/ui-ux-pro-max-skill/blob/28b3b8dee8c976df4fa3e94aed4e092ad43fcb03/README.md)                                                                                                              

| [Interface Design](https://github.com/Dammyjay93/interface-design/blob/2f9be3206855bcb2d1d0af262c8bae25cba6658d/README.md)                                                                                                                    

| [Vercel Web Interface Guidelines](https://github.com/vercel-labs/web-interface-guidelines/blob/434b7f91364665f2f733b310ec54809bf8f37937/command.md)                                                                                           

The upstream repositories identify these sources as MIT licensed: [shadcn](https://github.com/shadcn-ui/ui/blob/96da9cc7f1aa10580a3741664e2a77c721206c00/LICENSE.md), [UI UX Pro Max](https://github.com/nextlevelbuilder/ui-ux-pro-max-skill/bl

Call `copyText(text)` directly from the user's click handler and await its boolean result. It uses the [Clipboard API](https://developer.mozilla.org/en-US/docs/Web/API/Clipboard/writeText) when available and falls back to selection-based co

For a dialog or other focus trap, pass `copyText(text, { container: dialogElement })` when the trigger does not take focus. Otherwise the helper selects the nearest dialog containing the active element, or the document body. Its temporary f

- **Look for an `@nocobase` item first.** Before building a business component or page section yourself, search the UI Library: through the shadcn MCP server when your editor runs it (its search and example tools), otherwise with `pnpm exec

- **Offline, read the catalog.** When `https://ui.nocobase.com` cannot be reached, [`ui-library.md`](ui-library.md) lists every item with its kind, install command and location, description, plugin dependencies and example, as of this relea

End-to-end tests run against a running application. `playwright.config.ts` sets no `baseURL` or `webServer`, so start `pnpm dev` first and have each test read the application URL, including the deployment base path, from `APP_URL` (defaulti

- **Any token change** (a color, font, size, spacing, radius or shadow):   - With `pnpm dev` running, append `tests/fixtures/theme-tokens.html` to the `Local:` URL it prints, which already ends with the base path and a slash (`http://127.0.

- With `pnpm dev` running, append `tests/fixtures/theme-tokens.html` to the `Local:` URL it prints, which already ends with the base path and a slash (`http://127.0.0.1:13000/main/tests/fixtures/theme-tokens.html`). The page renders the rea

Every item of the `@nocobase` shadcn registry (the NocoBase UI Library, previewed at https://ui.nocobase.com), as of this release of the Skill. A component installs into `client/components/` and a block into `client/extensions/nocobase-<ite

# 1. Save the sign-in session: a browser window opens, the user signs in themselves, and the script never touches the password node .agents/skills/nocobase-app-development/references/frontend/scripts/capture.mjs login --base http://127.0.0.

node .agents/skills/nocobase-app-development/references/frontend/scripts/capture.mjs login --base http://127.0.0.1:13000/main/

The sign-in session is saved to `storage/ui-workflow/auth.json` (`storage/` is ignored by git). Do not commit or share it, and delete it when the task ends. For `--base`, pass the `Local:` URL `pnpm dev` prints (for example `http://127.0.0.

{   "base": "http://127.0.0.1:13000/main",

"base": "http://127.0.0.1:13000/main",

#!/usr/bin/env node

// // 1) Save the sign-in session (the user signs in themselves in the browser window that opens; the script never touches the password): //    node .agents/skills/nocobase-app-development/references/frontend/scripts/capture.mjs login --bas

// 1) Save the sign-in session (the user signs in themselves in the browser window that opens; the script never touches the password): //    node .agents/skills/nocobase-app-development/references/frontend/scripts/capture.mjs login --base h

//    node .agents/skills/nocobase-app-development/references/frontend/scripts/capture.mjs login --base http://127.0.0.1:13000/main/ [--timeout 10]

if (!base)     throw new Error(       'Missing --base, for example --base http://127.0.0.1:13000/main/',

throw new Error(       'Missing --base, for example --base http://127.0.0.1:13000/main/',     );

'Missing --base, for example --base http://127.0.0.1:13000/main/',

Bash(npx shadcn@latest *), Bash(pnpm dlx shadcn@latest *), Bash(bunx --bun shadcn@latest *)

**Named presets:** `nova`, `vega`, `maia`, `lyra`, `mira`, `luma` **Templates:** `next`, `vite`, `start`, `react-router`, `astro` (all support `--monorepo`) and `laravel` (not supported for monorepo) **Preset codes:** Version-prefixed base6

**Preset codes:** Version-prefixed base62 strings (e.g. `a2r6bw` or `b0`), from [ui.shadcn.com](https://ui.shadcn.com).

# Works with URLs too. npx shadcn@latest add https://api.npoint.io/abc123 --dry-run

npx shadcn@latest add https://api.npoint.io/abc123 --dry-run

input   docs      https://ui.shadcn.com/docs/components/radix/input

docs      https://ui.shadcn.com/docs/components/radix/input

examples  https://raw.githubusercontent.com/.../examples/input-example.tsx

button   docs      https://ui.shadcn.com/docs/components/radix/button

docs      https://ui.shadcn.com/docs/components/radix/button

examples  https://raw.githubusercontent.com/.../examples/button-example.tsx

1. **Named:** `--preset nova` or `--preset lyra` 2. **Code:** `--preset a2r6bw` (version-prefixed base62 string, e.g. `a2r6bw` or `b0`) 3. **URL:** `--preset "https://ui.shadcn.com/init?base=radix&style=nova&..."`

3. **URL:** `--preset "https://ui.shadcn.com/init?base=radix&style=nova&..."`

# Use a custom theme URL. npx shadcn@latest apply --preset "https://ui.shadcn.com/init?base=radix&style=nova&theme=blue&..."

npx shadcn@latest apply --preset "https://ui.shadcn.com/init?base=radix&style=nova&theme=blue&..."

{   "registries": {     "@acme": "https://acme.com/r/{name}.json",

"registries": {     "@acme": "https://acme.com/r/{name}.json",     "@private": {

"@acme": "https://acme.com/r/{name}.json",

[Credential-related source omitted]

"url": "https://private.com/r/{name}.json",

[Credential-related source omitted]

Community registry index: `https://ui.shadcn.com/r/registries.json`

{   "$schema": "https://ui.shadcn.com/schema/registry.json",

"$schema": "https://ui.shadcn.com/schema/registry.json",

"name": "acme",   "homepage": "https://acme.com",   "items": [

"homepage": "https://acme.com",

{   "$schema": "https://ui.shadcn.com/schema/registry.json",

"$schema": "https://ui.shadcn.com/schema/registry.json",

"name": "acme",   "homepage": "https://acme.com",   "include": ["registry/ui/registry.json", "registry/blocks/registry.json"]

"homepage": "https://acme.com",

| `@acme/button`                      | namespace | Item `button` from configured registry `@acme`.              | | `@acme/ui/button`                   | namespace | Item `ui/button` from configured registry `@acme`.           | | `https:/

| `@acme/ui/button`                   | namespace | Item `ui/button` from configured registry `@acme`.           | | `https://example.com/r/button.json` | url       | Built registry item JSON at that URL.                        | | `./butto

| `https://example.com/r/button.json` | url       | Built registry item JSON at that URL.                        |

-> resolve ref with git ls-remote   -> commit SHA   -> read https://raw.githubusercontent.com/{owner}/{repo}/{sha}/registry.json

-> commit SHA   -> read https://raw.githubusercontent.com/{owner}/{repo}/{sha}/registry.json   -> read includes and item files from the same SHA

-> read https://raw.githubusercontent.com/{owner}/{repo}/{sha}/registry.json

| Item         | Details                                                                 | | ------------ | ----------------------------------------------------------------------- | | Page         | `/<path>`, application URL `http://…/main

| ------------ | ----------------------------------------------------------------------- | | Page         | `/<path>`, application URL `http://…/main`                              | | Code version | Description of the changes at the time of

| Page         | `/<path>`, application URL `http://…/main`                              |

1. If the application is running, reuse it; if not, start it with `pnpm dev` and open the `Local:` URL it prints, which ends with the deployment base path and a slash (for example `http://127.0.0.1:13000/main/`), with the page's path append

Cleanup: first retain the confirmed decisions as described under Artifacts. Delete only the temporary task copies of `design.md`, `review-design.md`, `run.md`, `acceptance.md` and `capture.json`, and the sign-in sessions `storage/ui-workflo

Every route under `/api` follows these rules, whether the application or a plugin owns it. They are Google's API design guidelines ([aip.dev](https://google.aip.dev)) with one change: a custom method is separated by a slash, `/apps/{appId}/

Open `<origin><APP_BASE_PATH>/api/swagger/docs` in a browser where you are signed in, such as `http://127.0.0.1:13000/main/api/swagger/docs` for a local application at the default `/main`. Swagger UI sends the session cookie with every requ

[Credential-related source omitted]

Automatically request the required package's metadata from `https://pkg-v3.nocobase.com/` in the application directory using existing npm/pnpm credentials. Registry health, access to a public package or access to another commercial package 

env 'npm_config_@nocobase:registry=https://pkg-v3.nocobase.com/' npm_config_registry=https://pkg-v3.nocobase.com/ pnpm view <package> versions --json

env 'npm_config_@nocobase:registry=https://pkg-v3.nocobase.com/' npm_config_registry=https://pkg-v3.nocobase.com/ pnpm nocobase plugin register <package> --version <compatible-version>

public async execute({ jobId, signal }: JobExecutionContext): Promise<void> {     const response = await fetch(this.payload.url, {

const response = await fetch(this.payload.url, {

const receipt = await executor.addJob(   new PublishDocument({     url: 'https://publisher.example/documents',

new PublishDocument({     url: 'https://publisher.example/documents',     documentId: 'document-42',

url: 'https://publisher.example/documents',

expect((await request('/orders')).status).toBe(401);   const admin = await signIn(testApp, DEFAULT_ADMIN_CREDENTIALS);   expect((await admin.fetch('/orders')).status).toBe(200);

const admin = await signIn(testApp, DEFAULT_ADMIN_CREDENTIALS);   expect((await admin.fetch('/orders')).status).toBe(200); });

expect((await admin.fetch('/orders')).status).toBe(200);

},       },       app: { publicOrigin: 'http://localhost' },

},       app: { publicOrigin: 'http://localhost' },       auth: {

app: { publicOrigin: 'http://localhost' },

[Credential-related source omitted]

[Credential-related source omitted]

trustedOrigins: ['http://localhost'],

[Credential-related source omitted]

[Credential-related source omitted]

[Credential-related source omitted]

[Credential-related source omitted]

connections: ['main'],   config: {     app: { publicOrigin: 'http://localhost' },

config: {     app: { publicOrigin: 'http://localhost' },     auth: {

app: { publicOrigin: 'http://localhost' },

[Credential-related source omitted]

[Credential-related source omitted]

trustedOrigins: ['http://localhost'],

test('returns the administrator record after sign-in', async ({ testApp }) => {   const admin = await signIn(testApp, DEFAULT_ADMIN_CREDENTIALS);   const response = await admin.fetch(

const admin = await signIn(testApp, DEFAULT_ADMIN_CREDENTIALS);   const response = await admin.fetch(     `/users?q=${encodeURIComponent(admin.user.email)}`,

const response = await admin.fetch(

const created = await admin.fetch('/users', {

headers: {       'content-type': 'application/json',       origin: 'http://localhost',

'content-type': 'application/json',       origin: 'http://localhost',     },

origin: 'http://localhost',

const member = await signIn(testApp, credentials);   const forbidden = await member.fetch('/users');

const forbidden = await member.fetch('/users');

const saved = await admin.fetch(

test('returns 400 for an invalid page number', async ({ testApp }) => {   const admin = await signIn(testApp, DEFAULT_ADMIN_CREDENTIALS);   const response = await admin.fetch('/users?page=0');

const response = await admin.fetch('/users?page=0');

test('returns 404 for a missing user', async ({ testApp }) => {   const admin = await signIn(testApp, DEFAULT_ADMIN_CREDENTIALS);   const response = await admin.fetch('/users/server-test-missing-user', {

const admin = await signIn(testApp, DEFAULT_ADMIN_CREDENTIALS);   const response = await admin.fetch('/users/server-test-missing-user', {     method: 'PATCH',

const response = await admin.fetch('/users/server-test-missing-user', {

headers: {       'content-type': 'application/json',       origin: 'http://localhost',

'content-type': 'application/json',       origin: 'http://localhost',     },

origin: 'http://localhost',

`request('/users')` is anonymous and resolves below the application's API root, including its deployment base path. `signIn()` performs a real sign-in; `admin.fetch()` and `member.fetch()` attach the resulting session cookie. Pass `/users`,

Executable file

Executable file

Executable file

Executable file

Executable file

Executable file

Executable file

Executable file

Executable file

Executable file

Executable file

Executable file

Executable file

Executable file

Executable file

Executable file