marcogll/passkit-generator
1
0
Fork 0
mirror of https://github.com/marcogll/passkit-generator.git synced 2026-03-15 18:25:24 +00:00
Code Issues Packages Projects Releases Wiki Activity

Deleted factory.ts file

Browse Source
This commit is contained in:
Alexander Cerutti
2021-09-27 23:48:25 +02:00
parent ac1c994b75
commit e8a40c4554
3 changed files with 0 additions and 270 deletions
Download Patch File Download Diff File Expand all files Collapse all files

170
spec/factory.ts
View File

@@ -1,170 +0,0 @@
import { createPass } from "../lib/factory";
import formatMessage, { ERROR } from "../lib/messages";
import * as fs from "fs";
import * as path from "path";
describe("createPass", () => {
it("should throw if first argument is not provided", async () => {
await expectAsync(createPass(undefined)).toBeRejectedWithError(
formatMessage(ERROR.CP_NO_OPTS),
);
});
try {
let certificatesPath = "../certificates";
try {
fs.accessSync(path.resolve(__dirname, certificatesPath));
} catch (err) {
certificatesPath = "../certs";
try {
fs.accessSync(path.resolve(__dirname, certificatesPath));
} catch (err) {
certificatesPath = "";
}
}
if (certificatesPath) {
it("should return a pass instance", async () => {
await expectAsync(
createPass({
model: path.resolve(
__dirname,
"../examples/models/exampleBooking.pass",
),
certificates: {
signerCert: path.resolve(
__dirname,
certificatesPath,
"./signerCert.pem",
),
signerKey: {
keyFile: path.resolve(
__dirname,
certificatesPath,
"./signerKey.pem",
),
passphrase: "password1234",
},
wwdr: path.resolve(
__dirname,
certificatesPath,
"./WWDR.pem",
),
},
}),
).toBeResolved();
});
describe("Model validation", () => {
it("Should reject with non valid model", async () => {
await expectAsync(
createPass({
// @ts-expect-error
model: 0,
certificates: {
signerCert: path.resolve(
__dirname,
certificatesPath,
"./signerCert.pem",
),
signerKey: {
keyFile: path.resolve(
__dirname,
certificatesPath,
"./signerKey.pem",
),
passphrase: "password1234",
},
wwdr: path.resolve(
__dirname,
certificatesPath,
"./WWDR.pem",
),
},
}),
).toBeRejected();
await expectAsync(
createPass({
model: undefined,
certificates: {
signerCert: path.resolve(
__dirname,
certificatesPath,
"./signerCert.pem",
),
signerKey: {
keyFile: path.resolve(
__dirname,
certificatesPath,
"./signerKey.pem",
),
passphrase: "password1234",
},
wwdr: path.resolve(
__dirname,
certificatesPath,
"./WWDR.pem",
),
},
}),
).toBeRejected();
await expectAsync(
createPass({
model: null,
certificates: {
signerCert: path.resolve(
__dirname,
certificatesPath,
"./signerCert.pem",
),
signerKey: {
keyFile: path.resolve(
__dirname,
certificatesPath,
"./signerKey.pem",
),
passphrase: "password1234",
},
wwdr: path.resolve(
__dirname,
certificatesPath,
"./WWDR.pem",
),
},
}),
).toBeRejected();
await expectAsync(
createPass({
model: {},
certificates: {
signerCert: path.resolve(
__dirname,
certificatesPath,
"./signerCert.pem",
),
signerKey: {
keyFile: path.resolve(
__dirname,
certificatesPath,
"./signerKey.pem",
),
passphrase: "password1234",
},
wwdr: path.resolve(
__dirname,
certificatesPath,
"./WWDR.pem",
),
},
}),
).toBeRejected();
});
});
}
} catch (err) {}
});

99
src/factory.ts
View File

@@ -1,99 +0,0 @@
import { Pass } from "./pass";
import * as Schemas from "./schemas";
import formatMessage, { ERROR } from "./messages";
import { getModelContents, readCertificatesFromOptions } from "./parser";
import { splitBufferBundle } from "./utils";
import { AbstractModel, AbstractFactoryOptions } from "./abstract";
/**
* Creates a new Pass instance.
*
* @param options Options to be used to create the instance or an Abstract Model reference
* @param additionalBuffers More buffers (with file name) to be added on runtime (if you are downloading some files from the web)
* @param abstractMissingData Additional data for abstract models, that might vary from pass to pass.
*/
export async function createPass(
options: Schemas.FactoryOptions | InstanceType<typeof AbstractModel>,
additionalBuffers?: Schemas.BundleUnit,
abstractMissingData?: Omit<AbstractFactoryOptions, "model">,
): Promise<Pass> {
if (
!(
options &&
(options instanceof AbstractModel || Object.keys(options).length)
)
) {
throw new Error(formatMessage(ERROR.CP_NO_OPTS));
}
try {
if (options instanceof AbstractModel) {
let certificates: Schemas.CertificatesSchema;
let overrides: Schemas.OverridesSupportedOptions = {
...(options.overrides || {}),
...((abstractMissingData && abstractMissingData.overrides) ||
{}),
};
if (
!(
options.certificates &&
options.certificates.signerCert &&
options.certificates.signerKey
) &&
abstractMissingData.certificates
) {
certificates = Object.assign(
options.certificates,
await readCertificatesFromOptions(
abstractMissingData.certificates,
),
);
} else {
certificates = options.certificates;
}
return createPassInstance(
options.bundle,
certificates,
overrides,
additionalBuffers,
);
} else {
const [bundle, certificates] = await Promise.all([
getModelContents(options.model),
readCertificatesFromOptions(options.certificates),
]);
return createPassInstance(
bundle,
certificates,
options.overrides,
additionalBuffers,
);
}
} catch (err) {
throw new Error(formatMessage(ERROR.CP_INIT, "pass", err));
}
}
function createPassInstance(
model: Schemas.PartitionedBundle,
certificates: Schemas.CertificatesSchema,
overrides: Schemas.OverridesSupportedOptions,
additionalBuffers?: Schemas.BundleUnit,
) {
if (additionalBuffers) {
const [additionalL10n, additionalBundle] =
splitBufferBundle(additionalBuffers);
Object.assign(model["l10nBundle"], additionalL10n);
Object.assign(model["bundle"], additionalBundle);
}
return new Pass({
model,
certificates,
overrides,
});
}

1
src/index.ts
View File

@@ -1,7 +1,6 @@
export type { Pass } from "./pass"; export type { Pass } from "./pass";
export type { AbstractModel } from "./abstract"; export type { AbstractModel } from "./abstract";
export { createPass } from "./factory";
export { createAbstractModel } from "./abstract"; export { createAbstractModel } from "./abstract";
export { default as Bundle } from "./Bundle"; export { default as Bundle } from "./Bundle";